乐趣区

关于java:面试官Java反射是什么我回答不上来

作者：

jiezi

在

一.概念

反射就是把Java的各种成分映射成相应的Java类。

Class类的构造方法是private，由JVM创立。

反射是java语言的一个个性，它允程序在运行时（留神不是编译的时候）来进行自我查看并且对外部的成员进行操作。例如它容许一个java的类获取他所有的成员变量和办法并且显示进去。Java 的这一能力在理论利用中兴许用得不是很多，然而在其它的程序设计语言中基本就不存在这一个性。例如，Pascal、C 或者 C++ 中就没有方法在程序中取得函数定义相干的信息。（来自Sun）

JavaBean 是 reflection 的理论利用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动静的载入并获得 Java 组件(类) 的属性。

反射是从1.2就有的，前面的三大框架都会用到反射机制,波及到类”Class”,无奈间接new CLass()，其对象是内存里的一份字节码.　　

Class 类的实例示意正在运行的 Java 应用程序中的类和接口。枚举是一品种，正文是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具备雷同元素类型和维数的数组都共享该 Class 对象。

根本的 Java类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也示意为 Class 对象。Class 没有公共构造方法。

Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 办法主动结构的。

Person p1 = new Person();  
//上面的这三种形式都能够失去字节码  
CLass c1 = Date.class();  
p1.getClass();   
//若存在则加载，否则新建,往往应用第三种,类的名字在写源程序时不须要晓得，到运行时再传递过去  
Class.forName("java.lang.String");

Class.forName()字节码曾经加载到java虚拟机中，去失去字节码；java虚拟机中还没有生成字节码 用类加载器进行加载，加载的字节码缓冲到虚拟机中。　

思考上面这个简略的例子，让咱们看看 reflection 是如何工作的。

import java.lang.reflect.*;    

public class DumpMethods {    
   public static void main(String args[]) {    
      try {    
           Class c = Class.forName("java.util.Stack");    

           Method m[] = c.getDeclaredMethods();    

           for (int i = 0; i < m.length; i++)    
               System.out.println(m[i].toString());    
      }    
      catch (Throwable e){    
            System.err.println(e);    
      }    
   }    
}  

public synchronized java.lang.Object java.util.Stack.pop()   
public java.lang.Object java.util.Stack.push(java.lang.Object)   
public boolean java.util.Stack.empty()   
public synchronized java.lang.Object java.util.Stack.peek()   
public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各办法名以及它们的限制符和返回类型。这个程序应用 Class.forName 载入指定的类，而后调用 getDeclaredMethods 来获取这个类中定义了的办法列表。java.lang.reflect.Methods 是用来形容某个类中单个办法的一个类。

以下示例应用 Class 对象来显示对象的类名：

void printClassName(Object obj) {  
       System.out.println("The class of " + obj +  
                     " is " + obj.getClass().getName());  
}

还能够应用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：

System.out.println("The name of class Foo is: "+Foo.class.getName());

在没有对象实例的时候，次要有两种方法。

//取得类类型的两种形式          
Class cls1 = Role.class;          
Class cls2 = Class.forName("yui.Role");

留神第二种形式中，forName中的参数肯定是残缺的类名（包名+类名），并且这个办法须要捕捉异样。当初失去cls1就能够创立一个Role类的实例了，利用Class的newInstance办法相当于调用类的默认的结构器。

Object o = cls1.newInstance();   
//创立一个实例          
//Object o1 = new Role();   //与下面的办法等价

二.罕用办法　　

1.isPrimitive(判断是否是根本类型的字节码)

public class TestReflect {  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        String str = "abc";  
        Class cls1 = str.getClass();  
        Class cls2 = String.class;  
        Class cls3 = null;//必须要加上null  
        try {  
            cls3 = Class.forName("java.lang.String");  
        } catch (ClassNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        System.out.println(cls1==cls2);  
        System.out.println(cls1==cls3);  

        System.out.println(cls1.isPrimitive());  
        System.out.println(int.class.isPrimitive());//断定指定的 Class 对象是否示意一个根本类型。  
        System.out.println(int.class == Integer.class);  
        System.out.println(int.class == Integer.TYPE);  
        System.out.println(int[].class.isPrimitive());  
        System.out.println(int[].class.isArray());  
    }  
}

后果：

true  
true  
false  
true  
false  
true  
false  
true

2.getConstructor和getConstructors()

java中构造方法没有先后顺序，通过类型和参数个数辨别。　

public class TestReflect {  
    public static void main(String[] args) throws SecurityException, NoSuchMethodException {  
        // TODO Auto-generated method stub  
        String str = "abc";  

        System.out.println(String.class.getConstructor(StringBuffer.class));  
    }  
}

3.Filed类代表某一类中的一个成员变量。

import java.lang.reflect.Field;  
public class TestReflect {  
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {  
        ReflectPointer rp1 = new ReflectPointer(3,4);  
        Field fieldx = rp1.getClass().getField("x");//必须是x或者y  
        System.out.println(fieldx.get(rp1));  

        /*  
         * private的成员变量必须应用getDeclaredField，并setAccessible(true),否则看失去拿不到  
         */  
        Field fieldy = rp1.getClass().getDeclaredField("y");  
        fieldy.setAccessible(true);//暴力反射  
        System.out.println(fieldy.get(rp1));  

    }  
}  

class ReflectPointer {  

    public int x = 0;  
    private int y = 0;  

    public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source  
        super();  
        // TODO Auto-generated constructor stub  
        this.x = x;  
        this.y = y;  
    }  
}

三.典型例题

1.将所有String类型的成员变量里的b改成a。

import java.lang.reflect.Field;  
public class TestReflect {  
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {  
        ReflectPointer rp1 = new ReflectPointer(3,4);  
        changeBtoA(rp1);  
        System.out.println(rp1);  

    }  

    private static void changeBtoA(Object obj) throws RuntimeException, Exception {  
        Field[] fields = obj.getClass().getFields();  

        for(Field field : fields) {  
            //if(field.getType().equals(String.class))  
            //因为字节码只有一份,用equals语义不精确  
            if(field.getType()==String.class) {  
                String oldValue = (String)field.get(obj);  
                String newValue = oldValue.replace('b', 'a');  
                field.set(obj,newValue);  
            }  
        }  
    }  
}  

class ReflectPointer {  

    private int x = 0;  
    public int y = 0;  
    public String str1 = "ball";  
    public String str2 = "basketball";  
    public String str3 = "itcat";  

    public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source  
        super();  
        // TODO Auto-generated constructor stub  
        this.x = x;  
        this.y = y;  
    }  

    @Override  
    public String toString() {  
        return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="  
                + str3 + "]";  
    }  
}

2.写一个程序依据用户提供的类名，调用该类的里的main办法。

为什么要用反射的形式呢？

import java.lang.reflect.Field;  
import java.lang.reflect.Method;  

public class TestReflect {  
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {  
        String str = args[0];  
        /*  
         * 这样会数组角标越界，因为压根没有这个字符数组  
         * 须要右键在run as-configurations-arguments里输出b.Inter（残缺类名）  
         *   
         */  
        Method m = Class.forName(str).getMethod("main",String[].class);  
        //上面这两种形式都能够,main办法须要一个参数  

        m.invoke(null, new Object[]{new String[]{"111","222","333"}});  
        m.invoke(null, (Object)new String[]{"111","222","333"});//这个能够阐明，数组也是Object  
        /*  
         * m.invoke(null, new String[]{"111","222","333"})  
         * 下面的不能够,因为java会主动拆包  
         */  
    }  
}  

class Inter {  
    public static void main(String[] args) {  
        for(Object obj : args) {  
            System.out.println(obj);  
        }  
    }  
}

3.模仿 instanceof 操作符

class S {    
}     

public class IsInstance {    
   public static void main(String args[]) {    
      try {    
           Class cls = Class.forName("S");    
           boolean b1 = cls.isInstance(new Integer(37));    
           System.out.println(b1);    
           boolean b2 = cls.isInstance(new S());    
           System.out.println(b2);    
      }    
      catch (Throwable e) {    
           System.err.println(e);    
      }    
   }    
}

在这个例子中创立了一个S 类的 Class 对象，而后查看一些对象是否是S的实例。Integer(37) 不是，但 new S()是。

四.Method类

代表类（不是对象）中的某一办法。

import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
/*  
 * 人在黑板上画圆，波及三个对象,画圆须要圆心和半径，然而是公有的，画圆的办法  
 * 调配给人不适合。  
 *   
 * 司机踩刹车，司机只是给列车收回指令，刹车的动作还须要列车去实现。  
 *   
 * 面试常常考面向对象的设计，比方人关门，人只是去推门。  
 *   
 * 这就是专家模式：谁领有数据，谁就是专家,办法就调配给谁  
 */  
public class TestReflect {  
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {  
        String str = "shfsfs";  
        //包结尾是com示意是sun外部用的，java打头的才是用户的  
        Method mtCharAt = String.class.getMethod("charAt", int.class);  
        Object ch = mtCharAt.invoke(str,1);//若第一个参数是null，则必定是静态方法  
        System.out.println(ch);  

        System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4语法  

    }  

}

五.数组的反射

Array工具类用于实现数组的反射操作。

同类型同纬度有雷同的字节码。

int.class和Integer.class不是同一份字节码，Integer.TYPE，TYPE代表包装类对应的根本类的字节码 int.class==Integer.TYPE。

import java.util.Arrays;  

/*  
 * 从这个例子看出即使字节码雷同然而对象也不肯定雷同,基本不是一回事  
 *   
 */  
public class TestReflect {  
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {  
        int[] a = new int[3];  
        int[] b = new int[]{4,5,5};//间接赋值后不能够指定长度，否则ＣＥ  
        int[][] c = new int[3][2];  
        String[] d = new String[]{"jjj","kkkk"};  
        System.out.println(a==b);//false  
        System.out.println(a.getClass()==b.getClass());//true  
        //System.out.println(a.getClass()==d.getClass());    //比拟字节码a和cd也没法比  
        System.out.println(a.getClass());//输入class [I  
        System.out.println(a.getClass().getName());//输入[I,中括号示意数组，I示意整数  

        System.out.println(a.getClass().getSuperclass());//输入class java.lang.Object  
        System.out.println(d.getClass().getSuperclass());//输入class java.lang.Object  

        //因为父类都是Object,上面都是能够的  
        Object obj1 = a;//不可是Object[]  
        Object obj2 = b;  
        Object[] obj3 = c;//根本类型的一位数组只能够当做Object，非得还能够当做Object[]  
        Object obj4 = d;  

        //留神asList解决int[]和String[]的区别  
        System.out.println(Arrays.asList(b));//1.4没有可变参数，应用的是数组,[[I@1bc4459]  
        System.out.println(Arrays.asList(d));//[jjj, kkkk]  

    }  
}

六.结束语

以上就是反射机制的简略的应用，显然学过spring的敌人肯定明确了，为什么能够通过配置文件就能够让咱们取得指定的办法和变量，在咱们创建对象的时候都是通过传进string实现的，就如同你须要什么，咱们去为你生产，还有咱们始终在用Object,这就阐明java语言的动静个性，依赖性大大的升高了。

对于Java反射，你学废了么？

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章