基础加强之反射

1.反射的基石 class

（1）众多的人用一个什么类表示？众多的Java类用一个什么类表示？ 

Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

人-->Person
Java类-->Class

（2）Class类代表Java类，它的各个实例对象又分别对应什么呢？
对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可（3）分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？

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

    三种：

• 类名.class，例如，System.class
• 对象.getClass()，例如，new Date().getClass()
• Class.forName("类名")，例如，Class.forName("java.util.Date");//静态方法加载，在写源程序的时候不用知道就可以

• String str1="abc";
                  Class cls1= str1.getClass();
                  Class cls2=String.class;
                  Class cls3=Class.forName("java.lang.String");
                  System.out.println(cls1==cls2);
                  System.out.println(cls1==cls3);

  
  三种获取方式的结果都是一样的，都是同一份字节码文件

（4） System.out.println(cls1.isPrimitive());

isPrimitive（）此方法是验证类字节码是否是基本类型（int……）。

int.class==Integer.class 结果是false他们不是同一份字节码

而 int.class==Integer.TYPE 结果就是true。type表示的是包装类的基本类型的字节码

数组也是一种类型。用isArray（）判断

总之，只要是在原程序中出现的类型都有各自的Class实例对象，int[]、void……

2.反射概念和类

反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。 
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点

（1）Constructor类

Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法：
例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：
例子：    Constructor constructor = Class.forName(“java.lang.String”).getConstructor( StringBuffer.class);//获得方法时要用到上面相同的类型创建实例对象：

通常方式：String str = new String(new StringBuffer("abc"));
反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));

Class.newInstance()方法：
例子：String obj = (String)Class.forName("java.lang.String").newInstance();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

代码：

new String (new StringBuffer("abc"));
                //String.class.getConstructor(StringBuffer.class);
                Constructor constructor1= 
                        String.class.getConstructor(StringBuffer.class);
                String str2=
                        (String) constructor1.newInstance(new StringBuffer("abc"));
        //在编译器时并不知道constructor的具体类型所以告诉编译器（String）
                System.out.println(str2.charAt(2));

newInstance（）详解

在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式？这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。

Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如：

class c = Class.forName(“Example”);

factory = (ExampleInterface)c.newInstance();

其中ExampleInterface是Example的接口，可以写成如下形式：

String className = "Example";

class c = Class.forName(className);

factory = (ExampleInterface)c.newInstance();

进一步可以写成如下形式：

String className = readfromXMlConfig;//从xml 配置文件中获得字符串

class c = Class.forName(className);

factory = (ExampleInterface)c.newInstance();

上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。

从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。

现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。

最后用最简单的描述来区分new关键字和newInstance()方法的区别：

newInstance: 弱类型。低效率。只能调用无参构造。

new: 强类型。相对高效。能调用任何public构造。

（2） File类

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

获取一个类中的成员变量

这里有一个类包含x，y变量

package cn.itcast.day1;

public class ReflectPoint {
private int x;
public int y;
public ReflectPoint(int x, int y) {
	super();
	this.x = x;<pre class="java" name="code"> 
               

this.y = y;}}

用反射方式获取变量

 ReflectPoint pt1= new ReflectPoint(3,5);
                Field fieldY =pt1.getClass().getField("y");
                //filedY不是对象身上的变量。而是类上，要用它去取某个对象上对应的值
                System.out.println(fieldY.get(pt1));
                Field fieldX =pt1.getClass().getDeclaredField("x");
                //x是私有的直接用会报错,所以使用getDeclaredField方法
                fieldX.setAccessible(true);//暴力获取
                System.out.println(fieldX.get(pt1));

（3）Method

Method类代表某个类中的一个成员方法
得到类中的某一个方法：
例子：    Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);
调用方法：
通常方式：System.out.println(str.charAt(1));
反射方式： System.out.println(charAt.invoke(str, 1)); 
如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
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})形式。

Method methodCharAt= String.class.getMethod("charAt",int.class);
                System.out.println(methodCharAt.invoke(str1,1));
                //当invoke的第一参数是null则说明该方法为静态

（4）对接收数组参数的成员方法进行反射

目标：
写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后， 大家要明白为什么要用反射方式去调啊？
问题：
启动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的语法解释，因此会出现参数类型不对的问题。
解决办法：
mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
mainMethod.invoke(null,(Object)new String[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
（5）数组的反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

int[] a1=new int [3];

int[] a2 = new int [4];

sys(a1.getClass()==a2.getClass());

结果是true。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

int[] a1=new int [3];

int[] a2 = new int [4];

int[] []a3= new int [2][4];

String [ ]a4 =new String[3];

Object  aobj1=a1;//数组

Object  aobj2=a2;//数组

Object [ ] aobj3=a1;//int基本类型不可以作为Object[]

Object [ ] aobj4=a3;//int [ ]是数组他属于Object类型，可以作为Object

Object [ ] aobj5=a4;//String

Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作

（6)ArrayList HashSet的比较及Hashcode分析。

首先重写了Hashcode方法

public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + x;
	result = prime * result + y;
	return result;
}

Collection collecitons= new HashSet();

ReflectPoint pt1=new ReflectPoint(3,3);

ReflectPoint pt1=new ReflectPoint(5,3);

ReflectPoint pt1=new ReflectPoint(3,3);

collections.add(pt1);

collections.add(pt2);

collections.add(pt3);

pt1.y=7;

collections.remove(pt1);

这时我们在存储之后对y值进行修改后，发现删除没有成功，

因为修改y之后，变量在内存中的hashcode就变了，所以无法删除，这就造成了内存溢出

3.反射的作用

框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架要解决的核心问题
我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

总结：反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。在应用中主要是在我们 没有掌握类的信息、对象的信息的时候通过它来在未知的时候就可以提前对下一步进行操作！