一，能够分析类能力的程序称为“反射”，反射库（java.lang.reflect）提供了精心设计的工具集，以便编写能够动态操作Java代码的程序。

用一句经典的话概括反射：反射就是把java类中的各种成分映射成相应的java类。

二，在程序运行期间，java运行时系统始终为所有的对象维护一个类型标识。这个标识跟踪着每个对象所属的类。虚拟机利用该标识选择相应的方法执行。可以通过专门的Java类访问这些信息。保存这些信息的类被称为Class类。

如同一个Person对象表示一个特定的人一样，一个Class对象表示一个特定类的属性。

三，创建Class类对象有3中形式：

1，已知某对象，调用该对象的getClass()方法将返回一个Class类型的实例。

Person p;
Class cc = p.getClass();

2，调用静态方法forName获得类名对应的Class对象。

String ss = "java.util.Date";
Class cc = Class.forName(ss);

3，若T是任意的Java类型，T.class将代表匹配的类对象。

Class cc1 = java.util.Date.class;
Class cc2 = int.class;
Class cc3 = Double[].class

Class对象表示的是一个类型，而这个类型未必是一种类，如整型（int），数组（double[]）

四，最常见的关于Class对象的两个操作

1，getName()方法获得类的名字

Person pp;
syso(pp.getClass().getName()); //syso是System.out.println()的简写。

2，newInstance()方法快速创建一个类的实例

Person pp;
Person pp2 = pp.getClass().newInstance();

pp和pp2是2个不同的对象，newInstance()方法调用默认构造器初始化新对象，若没有默认构造器，会抛出异常。

五，在java.lang.reflect包中有3个类Field,Method和Constructor分别用于描述类的域（成员变量），方法和构造器。

Class类中的getField()，getMethod()，getConstructor()方法分别返回类提供的公有域，公有方法和公有构造器。

Class类中的getDeclaredField()，getDeclaredMethod()，getDeclaredConstructor()方法分别返回类提供的私有域，私有方法和私有构造器。

下面是一个关于上述这几个类和方法使用的示例。

package com.jimmy.reflect;

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

//创建一个类
class Son2{
	//私有的成员变量
	private double i;
	//默认构造函数和有参构造函数
	public Son2() {}
	public Son2(double i) {this.i = i;}
	//成员变量的set和get方法
	public void setter(double i) {this.i = i;}
	public double getter() {return i;}
}
//测试Class类的函数和反射库中的函数
public class test2 {
	public static void main(String[] args) throws Exception {
		//获得Son2类的Class对象。
		Class<?> cc = Son2.class;
		
		//先得到有参构造器的信息，再根据构造器的信息，由newInstance()函数创建一个Son2对象
		Constructor<?> constructor = cc.getConstructor(double.class);//要指定构造器参数的类型
		Son2 son = (Son2)constructor.newInstance(123);//newInstance()带上参数类型的实例。
		System.out.println(son.getter()); //输出被实例化对象son的成员变量的值：123.0。
		
		//先得到无参构造器的信息，再创建Son2对象
		Constructor<?> constructor1 = cc.getConstructor();
		Son2 son2 = (Son2)constructor1.newInstance();//Son2类中要有默认构造器
		System.out.println(son2.getter());//输出被实例化对象son2的成员变量的值：0.0。
		
		//由无参构造器创建对象时，可不必获得构造器，直接由Class对象调用newInstance()方法。
		Class<?> cc2 = Son2.class;
		Son2 son22 = (Son2)cc2.newInstance();
		System.out.println(son22.getter()); //输出被实例化对象son的成员变量的值：0.0
		
		//下面2个输出语句可看出cc保存类信息，输出的是“class + 类名”。cc.newInstance()是具体类的对象。
		System.out.println(cc);  //输出：class com.jimmy.reflect.Son2
		System.out.println(cc.newInstance());  //输出：com.jimmy.reflect.Son2@15db9742（对象的地址）
		
		//首先得到有参构造函数的信息，然后根据构造函数实例化一个对象。
		//由getDeclaredField()函数得到类里面的私有成员变量，访问私有成员变量要用setAccessible()函数设置访问权限。
		//Field类对象得到成员变量后还可以设置该变量的值，使用set()方法。
		Constructor<?> constructor2 = cc.getConstructor(double.class);
		Son2 son23 = (Son2)constructor2.newInstance(321);
		Field field = cc.getDeclaredField("i");
		field.setAccessible(true);
		field.set(son23, 213);
		System.out.println(field.get(son23));  //field.get(对象)返回获得的对应域的值。
		
		//首先根据获得的构造函数信息实例化一个对象
		//然后由函数名获得类中的公有函数，getMethod("函数名")
		//invoke()方法执行由getMethod()获得的函数，这里获得的函数是getter()
		//对于获得的无参函数，invoke(对象)里只添加对象名。
		Constructor<?> constructor3 = cc.getConstructor(double.class);
		Son2 son24 = (Son2)constructor3.newInstance(231);
		System.out.println(cc.getMethod("getter").invoke(son24)); //输出函数执行返回的结果
		
		//对于获得到的有参函数，在调用getMethod()函数时，要在getMethod()中指定被获得函数的"函数名"和"参数类型"
		//并且在执行该函数（即调用invoke()函数时），要指定对象和参数类型的具体实例。
		Son2 son25 = (Son2)cc.newInstance(); 
		Method method = cc.getMethod("setter", double.class);
		method.invoke(son25, 123);
		System.out.println(son25.getter());  //输出函数执行返回的结果。
		
		//反射包里还有一个重要的类：Modifier，该类是静态类，其中的方法也都是静态方法
		//Class类中getModifiers()函数返回一个用于描述类，构造器，方法和域的修饰符的整形数值。、
		//调用Modifier.toString()方法将整型数值转变成字符串，也是就我们熟悉的public，private，static，final等修饰符。
		System.out.println(Modifier.toString(cc.getModifiers()));
		System.out.println(Modifier.toString(constructor.getModifiers()));
		System.out.println(Modifier.toString(field.getModifiers()));
		System.out.println(Modifier.toString(method.getModifiers()));
		//同时，Modifier类还有一些判断修饰符是不是某一类型的方法。
		System.out.println(Modifier.isPublic(cc.getModifiers()));
		System.out.println(Modifier.isPublic(constructor.getModifiers()));
	}
}

六，应用反射调用其他类的main()方法

首先有一个类，main()方法输出信息：

package com.jimmy.reflect;

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

在其他类中反射调用上面类的main（）方法。

package com.jimmy.reflect;

import java.lang.reflect.Method;

public class getMain {
	public static void main(String[] args) throws Exception {
		//传统方法
		testPrint.main(new String[]{"haha","xixi"});
		//反射调用
		Class<?> cc = Class.forName("com.jimmy.reflect.testPrint");
		Method mm = cc.getMethod("main", String[].class);
		mm.invoke(null, (Object)new String[]{"hello","jimmy"});//实例化字符串数组对象时要在前面加（Object），不然会报参数个数不匹配的错误。
	}
}

七，数组的反射

package com.jimmy.reflect;

import java.lang.reflect.Array;

public class test3 {
	public static void main(String[] args) throws Exception {
		//新建4个不同的数组
		int[] a = new int[3];
		int[] b = new int[4];
		int[][] c = new int[3][4];
		String[] d = new String[3];
		//可以对比各个数组所属的类是否相同
		System.out.println(a.getClass() == b.getClass());
//		System.out.println(a.getClass() == c.getClass()); //不同的类不能比较是否相等，会报错
//		System.out.println(a.getClass() == d.getClass());
		System.out.println(a.getClass().getName());
		System.out.println(d.getClass().getName());
		System.out.println(a.getClass().getSuperclass().getName());
		//利用静态方法反射生成一个数组
		int[] aa = (int[]) Array.newInstance(int.class, 3);
		Array.set(aa, 0, 123);//set()静态方法赋值
		Array.set(aa, 1, 321);
		Array.set(aa, 2, 213);
		System.out.println(Array.get(aa, 0));//get()静态方法取值
		System.out.println(Array.get(aa, 1));
		System.out.println(Array.get(aa, 2));
		//获得数组类型的常用方式
		Class<?> cc = String[].class;
		Class<?> cc1 = Class.forName("[I");
		Class<?> cc2 = Class.forName("[Ljava.lang.String;");		
		System.out.println(cc);
		System.out.println(cc1);
		System.out.println(cc2);
		//通过已有对象获取数组类型
		Class<?> cc3 = aa.getClass();
		System.out.println(cc3);
		Class<?> cc4 = cc3.getComponentType();//根据类型信息获取数组内成员的类型
		System.out.println(cc4);
	}
}