黑马程序员Java高新__反射

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、反射

一）概述：把Java类中的各种成分映射成相应的Java类。       

如Class中的每一个方法返回的都是一种类（型），即Method对所有方法抽取成了这个类Method，它的每一个对象（如变量methodObj1）代表了一个方法。

1）组成成分：

成员变量、方法、构造函数、包等信息，也用一个个java类来表示（如汽车是一个类，其中的发动机，变速箱等也是对应的一个个类），表示Java类的Class类显然要提供一系列的方法来获取其中的变量、方法、构造函数、修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等。

2）一个类中的每个成员都可用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可得到这些实例对象。

二）反射的基石（Class）

1、如何得到各个字节码对应的实例对象（ Class类型）？

 

1） 类名.class，例如，System.class。

2）对象.getClass()，例如，new Date().getClass()。

3）Class.forName("类名")，例如，Class.forName("java.util.Date")。

2、九个预定义的Class：

1）包括八种基本类型（byte、short、int、long、float、double、char、boolean）的字节码对象和一种返回值为void类型的void.class。

2） Int.class == Integer.TYPE

3）数组类型的Class实例对象： Class.isArray()。

示例1：

String str1="abc";  
    
  //获取str1的字节码文件  
  Class cls1=str1.getClass();  
    
  //获取String的字节码文件  
  Class cls2=String.class;  
    
  //返回与带有给定字符串名的类或接口相关联的 Class 对象  
  Class cls3=Class.forName("java.lang.String");  
  System.out.println(cls1==cls2);//true  
  System.out.println(cls1==cls3);//true  
    
  //isPrimitive()  cls1是不是基本类型(字符串不是基本类型)  
  System.out.println(cls1.isPrimitive());  
    
  //判断int是不是基本类型.true  
  System.out.println(int.class.isPrimitive());  
    
  //判断int和Integer两个类的字节码是否相同false  
  System.out.println(int.class == Integer.class);  
    
  //TYPE表示基本类型 int 的 Class 实例。 true  
  System.out.println(int.class == Integer.TYPE);  
    
  //数组不是基本类型false  
  System.out.println(int[].class.isPrimitive());  
    
  //判断是否是一个数组类.isArray();true  
  System.out.println(int[].class.isArray()); 

三） Constructor类

1、概述：Constructor代表某个类的构造方法。

2、获取构造方法：

1）如何得到摸个类的所有构造方法：如得到String类的所有构造方法：Constructor[] cons = Class.forName(“java.lang.String”).getConstructors()；

2）获取某一个构造方法：Constructor con =String.class.getConstructor(StringBuffer.class);

3、创建实例对象：

1）通常方式：String str = new String(new StringBuffer (”abc”));

2）反射方式：String str = (String)con.newInstance(new StringBuffer(“abc”));调用获得的方法时要用到上面相同类型的实例对象。

4、Class.newInstance()：创建一个对象，不带参数的构造方法。

示例2：

//new String(new StringBuffer("abc"));   
Constructor constructor1 =   
String.class.getConstructor(StringBuffer.class);  
String str2 =  
 (String)constructor1.newInstance(new StringBuffer("abc"));  
System.out.println(str2);  
          
//Class.newInstrance创建不带参数的构造方法   
String str3 =   
(String)Class.forName("java.lang.String").newInstance();  
System.out.println("str3:"+str3);  

四） Field类

1、概述：Field类代表成员变量（字段）的反射。

示例3：

public class ReflectPoint {  
    private int x;  
    public int y;  
  
    public String toString(){  
        return str1+";" + str2 + ";" + str3;  
    }  
}  
public class FieldTest(){  
ReflectPoint pt1 = new ReflectPoint(3,5);  
    //fieldX和fieldY并不是对象身上的变量，而是类上的   
    //要用它去取某个对象上的对应的值，传入什么对象，就取相应对象的值。   
    Field fieldY = pt1.getClass().getField("y");  
    System.out.println(fieldY.get(pt1));  
    //获取私有的成员变量   
Field fieldX = pt1.getClass().getDeclaredField("x");  
    fieldX.setAccessible(true);  
    System.out.println(fieldX.get(pt1));  
} 

2、获取成员变量：

1）获取公有的成员变量：getField(String name)和get(变量)

2）获取私有的成员变量：暴力反射 getDeclared(String name)、setAccessible(true)和get(变量)

示例4：

//替换字符    
private static void changeStringValue(Object obj) throws Exception {  
    Field[] fields = obj.getClass().getFields();  
    for(Field field : fields){  
        //此处需要用==比较，因为是同一份字节码对象   
        if(field.getType() == String.class){  
            String oldValue = (String)field.get(obj);  
            String newValue = oldValue.replace('b','a');  
            field.set(obj, newValue);  
        }  
    }  
}  

五）Method类

 

1、概述：Method类代表某个类中的一个成员方法。

2、得到类中的某一个方法：

      例：Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

 

3、调用方法：

通常方式：System.out.println(str.charAt(1));
反射方式： System.out.println(charAt.invoke(str, 1));

 

4、如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法。

 

5、用反射方式执行某个main方法：

首先要明确为何要用反射：在写源程序时，并不知道使用者传入的类名是什么，但是虽然传入的类名不知道，而知道的是这个类中的方法有main这个方法，所以可以通过反射的方式，通过使用者传入的类名（可定义字符串型变量作为传入类名的入口，通过这个变量代表类名），内部通过传入的类名获取其main方法，然后执行相应的内容。

示例5：

//Method类演示   
private static void methodTest(String [] args) throws Exception {  
    String str1 = "abc";  
    //一般方法：   
    System.out.println(str1.charAt(1));  
    //反射方法 ：   
    Method methodCharAt =  
        Class.forName("java.lang.String").getMethod("charAt",int.class);  
    System.out.println(methodCharAt.invoke(str1,1));  
      
    //用反射方式执行某个main方法   
    //一般方式：   
    Test.main(new String[]{"111","222","333"});  
    System.out.println("-------");  
      
    //反射方式：   
    String startingClassName = args[0];  
    Method methodMain =  
        Class.forName(startingClassName).getMethod("main",String[].class);  
        //方案一：强制转换为超类Object，不用拆包   
        methodMain.invoke(null,(Object)new String[]{"111","222","333"});  
        //方案二：将数组打包，编译器拆包后就是一个String[]类型的整体   
        methodMain.invoke(null,new Object[]{new String[]{"111","222","333"}});  
    }  
//定义一个测试类   
class Test{  
    public static void main(String [] args){  
        for(String arg : args){  
            System.out.println(arg);  
        }  
    }  
}  

六）数组的反射

演示：

//  
  int[] a1=new int[]{1,2,3};  
  
  int[] a2=new int[4];  
  
  int[][] a3=new int[3][4];  
  
  String[] a4=new String[]{"aaa","bbb","ccc"};  
  
  System.out.println(a1.getClass()==a2.getClass());//true  
  
  System.out.println(a1.getClass()==a3.getClass());//false  
  
  System.out.println(a1.getClass()==a4.getClass());//false  
     
  printObject(a1);  
  
  private static void printObject(Object obj) {  
  //判断穿进去的类型是否是数组  
  if(obj.getClass().isArray()){  
  //如果是调用Array的静态方法getLength获取Obj的长度  
  int len = Array.getLength(obj);  
  //然后遍历obj,并打印数组中的元素  
  for(int i=0;i<len;i++) {  
  
  System.out.println(Array.get(obj, i));  
  
  }  
  } else {  
  //如果不是数组直接打印  
  System.out.println(obj);  
  }  
 }  

七、框架

一）框架：通过反射调用位置Java类的一种方式。

如房地产商造房子用户住，门窗和空调等等内部都是由用户自己安装，房子就是框架，用户需使用此框架，安好门窗等放入到房地产商提供的框架中。

框架和工具类的区别：工具类被用户类调用，而框架是调用用户提供的类。

二）框架机器要解决的核心问题：

我们在写框架（造房子的过程）的时候，调用的类（安装的门窗等）还未出现，那么，框架无法知道要被调用的类名，所以在程序中无法直接new其某个类的实例对象，而要用反射来做。

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------