黑马程序员-Java高新技术(反射)

------- android培训、 java培训、期待与您交流！ ----------

反射的基石：Class类
1.Class是Java程序中各个Java类的总称；它是反射的基石，通过Class类来使用反射。
2.Class和class的区别
  (1)class：Java中的类用于描述一类事物的共性，该类事物有什么属性，至于这个属性的值是什么，则由此类的实例对象确定，不同的实例对象有不同的属性值。
  (2)Class：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类，这些类称为Class。例如人对应的是Person类，Java类对应的就是Class。
3.对象的创建
  (1)类名.class：如System.class，String.class等等
  (2)对象.class：如new Date().getClass()或者d.getClass()。（Date d = new Date()）
  (3)Class.forName(“类名”)：如Class.forName(”java.lang.String”)
4.九个预定义的Class
  (1)包括八种基本类型（byte、short、int、long、float、double、char、boolean）的字节码对象和一种返回值为void类型的void.class
  (2)Integer.TYPE是Integer类的一个常量，它代表此包装类型包装的基本类型的字节码，所以和int.class是相等的。
  (3)基本数据类型的字节码都可以用与之对应的包装类中的TYPE常量表示.
  (4)数组类型的Class实例对象，可以用Class.isArray()方法判断是否为数组类型的。
5.成员方法
  (1)static Class forName(String className)
返回与给定字符串名的类或接口的相关联的Class对象。
  (2)Class getClass()
返回的是Object运行时的类，即返回Class对象即字节码对象
  (3)Constructor getConstructor()
返回Constructor对象，它反映此Class对象所表示的类的指定公共构造方法。
  (4)Field getField(String name)
返回一个Field对象，它表示此Class对象所代表的类或接口的指定公共成员字段。
  (5)Field[] getFields()
返回包含某些Field对象的数组，表示所代表类中的成员字段。
  (6)Method getMethod(String name,Class… parameterTypes)
返回一个Method对象，它表示的是此Class对象所代表的类的指定公共成员方法。
  (7)Method[] getMehtods()
返回一个包含某些Method对象的数组，是所代表的的类中的公共成员方法。
  (8)String getName()
以String形式返回此Class对象所表示的实体名称。
  (9)String  getSuperclass()
返回此Class所表示的类的超类的名称
  (10)boolean isArray()
判定此Class对象是否表示一个数组
  (11)boolean isPrimitive()
判断指定的Class对象是否是一个基本类型。
  (12)T newInstance()
创建此Class对象所表示的类的一个新实例。

代码演示

class demo{
	public static void main(String[] args){
		String str1 = "abc";  
		Class cls1 = str1.getClass();  
		Class cls2 = String.class;  
		Class cls3 = Class.forName("java.lang.String");  
		System.out.println(cls1 == cls2);//true  
		System.out.println(cls1 == cls3);//true  
  
		//public boolean isPrimitive()  
		//判定指定的 Class 对象是否表示一个基本类型。 八个基本类型和void  
		System.out.println(cls1.isPrimitive());//false  
		System.out.println(int.class.isPrimitive());//true  
		System.out.println(int.class == Integer.class);//false  
	}
}

反射
1.反射就是把Java类中的各种成分映射成相应的java类
2.一个类中的组成成分
  成员变量、方法、构造函数、包等信息，也用一个个java类来表示（如汽车是一个类，其中的发动机，变速箱等也是对应的一个个类），表示Java类的Class类显然要提供一系列的方法来获取其中的变量、方法、构造函数、修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等。
3.一个类中的每个成员都可用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可得到这些实例对象。
4.反射中的各种类


Constructor类     
代表某个类的构造方法
1.得到某个类所有的构造方法：
例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
2.得到某一个构造方法：
例子：    Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时要用到类型
3.创建实例对象：
通常方式：String str = new String(new StringBuffer("abc"));
反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象
4.Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

代码演示：

class demo2{
	public static void main(String[] args){
		//new String(new StringBuffer("abc"));  
		//public Constructor<T> getConstructor(Class<?>... parameterTypes)  
		//参数是参数类型返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法  
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);  
  
		//public T newInstance(Object... initargs)  
		//使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。  
		//如果是"abc"运行报错参数不匹配，因为这个构造方法对应的是接收StringBuffer类型的构造方法，你在调用的时候传来String  
		//而不是启动一个StringBuffer，编译期看不到，因为编译器只知道你是构造方法，所以运行就报错  
		String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));  
		System.out.println(str2.charAt(2));//c  
	}
}

Field类 
代表某个类中的一个成员变量
1.演示用eclipse自动生成Java类的构造方法
2.问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。
3.示例代码：

class demo3{
	public static void main(String[] args){
		ReflectPoint point = new ReflectPoint(1,7);
		Field y = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
		System.out.println(y.get(point));
		//Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
		Field x = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
		x.setAccessible(true);
		System.out.println(x.get(point));
	}
}

代码演示：

class FieldDemo{
	public static void main(String[] args){
		ReflectPoint pt1 = new ReflectPoint(3,5);  
		//public Field getField(String name)  
		//参数是字段名，返回一个 Field对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。  
		Field fieldY = pt1.getClass().getField("y");  
		//fieldY的值是多少？是5,错！fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值  
		System.out.println(fieldY.get(pt1));//5  
  
		//public Field getDeclaredField(String name)  
		//参数字段名，返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。  
		Field fieldX = pt1.getClass().getDeclaredField("x");  
  
		//public void setAccessible(boolean flag)  
		//值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。用于访问私有变量。  
		fieldX.setAccessible(true);  
		System.out.println(fieldX.get(pt1));//3   
	}
}

Method类
代表某个类中的一个成员方法
1.得到类中的某一个方法：
例子：    Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);
2.调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式： System.out.println(charAt.invoke(str, 1)); 
如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
3.jdk1.4和jdk1.5的invoke方法的区别：
Jdk1.5：public Object invoke(Object obj,Object... args)
Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

代码演示：

class MethodDemo{
	public static void main(String[] args){
		//public Method getMethod(String name,Class<?>... parameterTypes)  
		//返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。  
		//每一个参数是方法名，第二个参数是参数列表  
Method methodCharAt = String.class.getMethod("charAt", int.class);  
		//public Object invoke(Object obj,Object... args)  
		//对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。  
		//参数：   obj - 从中调用底层方法的对象，args - 用于方法调用的参数  
		//如果是静态方法可以忽略对象，参数为null  
		System.out.println(methodCharAt.invoke(str1, 1));//b  
		System.out.println(methodCharAt.invoke(str1, new Object[]{2}));//c  
	}
}

用反射方式执行某个main方法
1.目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？
2.问题：
启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
3.解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

代码演示：

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);    
        }    
    }    
}    

数组的反射
1.具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
2.代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的3.一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
4.Arrays.asList()方法处理int[]和String[]时的差异。
5.Array工具类用于完成对数组的反射操作。

代码演示：

class ArrayDemo{
	public static void main(String[] args){
		int [] a1 = new int[]{1,2,3};  
		int [] a2 = new int[4];  
		int[][] a3 = new int[2][3];  
		String [] a4 = new String[]{"a","b","c"};  
		System.out.println(a1.getClass() == a2.getClass());//true  
		//System.out.println(a1.getClass() == a4.getClass());//false  
		//System.out.println(a1.getClass() == a3.getClass());//false  
		System.out.println(a1.getClass().getName());//[I  
		System.out.println(a3.getClass().getName());//[[I  
		System.out.println(a4.getClass().getName());//[Ljava.lang.String;  
		System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object  
		System.out.println(a4.getClass().getSuperclass().getName());//java.lang.Object  
  
		Object aObj1 = a1;  
		Object aObj2 = a4;  
		//基本类型的一维数组，它是不能转换成Object数组的，因为int数组里装的是int类型不是Object的  
		//Object[] aObj3 = a1;  
		Object[] aObj4 = a3;  
		Object[] aObj5 = a4;  
  
		System.out.println(a1);//[I@30c028cc  
		System.out.println(a4);//[Ljava.lang.String;@17b68215  
	}
}

反射的作用-实现框架功能
1.框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
2.框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。
3.综合案例
先直接用new  语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成 ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。
引入了elipse对资源文件的管理方式的讲解。