Java反射的原理：
类也是对象
所有的类都是java.long.Class类的实例对象
Class类的构造方法是私有的
任何一个类都是Class的实例对象实例对象有3种表达方式：
Class c1 = Test.class; //任何一个类都有一个隐含的静态成员变量class
Class c2 = t1.getClass(); //c1,c2是指Test类的类类型
Class c3 = Class.forName("Test"); // 需要try, catch, 类的全称
c1==c2==c3为true
Test t = (Test) c1.newInstance(); // 需要try ， catch， 无参构造方法
- 类加载的方法
编译时刻加载的类：静态加载类
运行时刻加载的类：动态加载类
new对象是静态加载，在编译时需要加载所有可能使用的类
动态加载：
class dynamicLoad{
public static void main (String[] args){
try{
Class c = Class.forName(args[0]);
Interface i = (Interface)c.newInstance(); // 通过统一接口声明对象
}catch(Exception e){
e.printStackTrace();
}
}
}
public class classUtil{
public static void printClassMessage(Object obj){
Class c = obj.getClass();
System.out.println("类名称：" + c.getName());
Method[] ms = c.getMethods();//获取本类以及父类或者父接口中所有的公共方法（public）
//c.getDeclaredMethods();获取所有方法(private、protected、默认以及public)
for ( int i = 0; i < ms.length; i++){
Class returnType = ms[i].getReturnType();
System.out.println(returnType.getName() + ms[i].getName() + ms[i].getParameterType());
}
}
}
- 成员变量也是对象，
java.long.reflect.Field的对象。Field类封装了所有关于成员变量的操作。
Field[] fs = c.getDeclaredField();
Class fieldType = field.getType();
String typeName = filedType.getName();
String fieldName = field.getName();
- 构造函数也是对象：
Constructor[] cs = c.getConstructors(); // c.getDeclaredConstructors();
String csName = c.getName();
String[] csType = c. getParameterTypes();
方法的反射
- 如何调用方法的反射：
method.invoke(对象，参数列表)
A a1 = new A();
Class c = a1. getClass();
c.getMethod(name, parameterType);//c.getDeclaredMethod();
Method m = c.getMethod("print", int.class, int.class); // c.getMethod("print", new Class[]{int.class, int.class});
Object o = m.invoke(a1, new Object[]{10, 20});
//返回null，或进行强制类型转换;
//m.invoke(a1,10,20);
通过反射认识泛型的本质
ArrayList list1 = new ArrayList();
ArrayList<String> list2 = new ArrayList<String>();
Class c1 = list1.getClass();
Class c2 = list2.getClass();
c1==c2 true
编译之后的集合是去泛型化的，即Java中的泛型是防止错误输入的，只在编译阶段有效，绕过编译就无效了
通过反射可以在String类型的ArrayList<String>中加入Integer等类型的元素
特别说明：通过反射修改final值
使用final关键字修饰一个数据时，表示该数据不可更改，但是可以利用反射的特性对final的属性进行修改
对于Object类中的final属性type，我们可以使用反射进行修改
private final String type = "A";
*************************************
Object o = new Object();
Field field = o.getClass().getDeclaredField("type");
field.setAccessible(true);
field.set(o,"B");
System.out.println(field.get(o));
虽然修改的代码，但是在打印时，控制台打印的仍然为原始的属性值，即输出A。
这是由于JVM将final修饰了属性当做常量处理，即把所有使用type属性的语句直接用A替代，因此System.out.println("type")被优化为System.out.println("A")，使得修改的final属性并未影响到打印的结果。
要想取消内联，需要将代码复杂化，使得JVM不能简单地替换：
private final String type=(null!=null?"A":"A").
但是如果是static修饰的final字段，就不能简单的使用反射修改了，修改static final修饰的属性会抛出异常：java.lang.IllegalAccessException: Can not set static final int field...
因此，需要修改Field里面的modifiers数据域，清除代表final的那个bit
Object o = new Object();
Field field = o.getClass().getDeclaredField("type");
Field modifiers = field.getClass().getDeclaredField("modifiers");
modifiers.setAccessible(true);
modifiers.setInt(field, field.getModifiers() & ~Modifier.FINAL);
field.set(o,"B");
System.out.println(field.get(o));
o.printName();
将final修饰符去掉后，就可以修改该属性值了。
