java反射基础知识
Java程序中的对象在运行时会出现两种类型：编译时类型和运行时类型，例如：
Animal a=new Dog();//多态，父类的引用指向子类的对象。在编译时变量a会被认为是Animal类型（父类），而运行时a会被认为是Dog类型（子类型）。
此外，有的程序在运行时接收外部传入的对象，编译时类型为Object，但运行时需要调用该对象运行时类型的属性或方法。
为解决这种问题，程序需要在运行时发现对象和类的真是信息。Java中有两种方法：
第一种：假设在编译和运行时都完全知道类型的具体信息，则可以通过直接使用instanceof判断，再强制类型转换为运行时的变量。
第二种：编译时无法预知该对象和类型可能属于哪些类，程序只能依靠运行时信息来发现该类和对象的真实信息，在这种情况下，必须使用反射。
反射，是指在java中，在运行期可以载入、探知和使用编译期完全未知的类。
反射的作用：获取类的完整信息、动态创建和操纵对象、调用方法、访问属性、动态创建和访问数组。
在Java程序中有三中获得Class对象的方式：
1.编译期不知道类名，运行期可以获得该类名时，使用Class类的静态方法forName()获得Class对象。
Class cls=Class.forName("全限定名");注意：这种方式必须使用全限定名！
2.编译期知道类名。可以调用该类的class属性获得该类的Class对象。
Class cls=类名.class;这里的类名不一定要使用全限定名，仅仅是类名标识符，如果不同包，则导入类即可，也可以使用全限定名，这样不需要导入类
3.如果已经得到一个类的实例对象，调用该对象的getClass()方法也可以获得该类的Class对象
User user=new User();
Class cls=user.getClass();
在Class类中，通过getFiedls()、getMethods()、getConstructors()方法，可以获得Class所含类的public属性、pulic方法和pulic构造器（返回一个元素类型为Field/Method/Constructor的数组），可以获取到从父类继承来的属性和方法。而getDeclaredFields()、getDeclaredMethods()、getDeclaredConstructors()可以获得Class包含的类中定义的所有属性、方法和构造器（返回一个元素类型为Field/Method/Constructor的数组），但是不能获取到从父类继承的属性和方法。在使用时需要根据需要决定调用合适的方法。
在java中创建对象的方式有四种：new、反射、对象克隆、对象反序列化。
一、使用反射生成并操纵对象
反射创建对象的方式有两种：
1.使用Class对象的newInstance()方法创建该类对应的实例，这种方式实际上调用的是默认的构造器，因此要求Class对象对应的类必须有默认的构造器（无参构造器）。
2.先通过Class对象获取指定的Constructor对象(通过给出参数列表)，再调用Constructor对象的newInstance()方法创建该类对应的实例（创建时需要传递对应参数）。
package com.test;
/**测试通过反射创建对象*/
import java.lang.reflect.Constructor;
public class CreateNewObject {
public CreateNewObject(String str) {
System.out.println(str);
}
public CreateNewObject(int a, int b){
System.out.println("a="+a+" b="+b);
}
public static void main(String[] args) {
try {
Class cls=Class.forName("com.test.CreateNewObject");//获得Class对象
Class []paramTypes=new Class[2];//定义参数类型，表示有2个参数
paramTypes[0]=Integer.TYPE;//基础数据类型用.TYPE
paramTypes[1]=Integer.TYPE;
//获取指定的构造器,也可以直接写成cls.getDeclaredConstructor(Integer.TYPE,Integer.TYPE);
Constructor ct=cls.getConstructor(paramTypes);
Object[]arglist=new Object[2];//为newInstance定义参数，这里表示有2个参数
arglist[0]=new Integer(30);
arglist[1]=new Integer(20);
//传递参数，调用指定构造器的newInstance()方法创建实例，也可以直接写成ct.newInstance(Integer.TYPE,Integer.TYPE);
ct.newInstance(arglist);
ct=cls.getConstructor(String.class);
ct.newInstance("调用一个字符串参数的构造器");
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果如下：
a=30 b=20
调用一个字符串参数的构造器
二.调用方法
1.获得Class对象
2.通过Class对象的getMethod()或者getDeclaredMethod()方法获得指定的Method对象（根据访问修饰符确定）。这一步需要传递参数，第一个参数为方法名（必填），第二个及以后的参数表示该方法的参数列表。
参数列表不是必须的，如果一个方法是无参的，那么在获得getMethod()/getDeclaredMethod()时第二个参数可以填null，也可以直接不填，只有一个方法名作为参数，例如：
Class cls=Class.forName(com.Test);//获得Class对象
//获得名为test的无参数的方法的Method对象
cls.getDeclaredMethod("test");//正确
或者cls.getDeclaredMethod("test",null);//也正确
代码如下：
package com.test;
import java.lang.reflect.Method;
//通过反射调用方法
public class ExcuteMethod {
public int add(int a,int b){
return a+b;
}
public String[] test(){
String []strs={"1","2"};
return strs;
}
public static void main(String[] args) {
try {
Class cls=Class.forName("com.test.ExcuteMethod");
Method m=cls.getMethod("add", Integer.TYPE,Integer.TYPE);
ExcuteMethod excMeth=new ExcuteMethod();
//第一个参数必须指定一个对象，用该对象调用方法，第二个参数起直到最后是给定的参数
int a=(int)(m.invoke(excMeth,2,2));//使用反射调用方法的时候返回的是Object类型，需要类型还原,这里只是为了演示，本程序直接打印返回的object对结果没影响
System.out.println(a);
Method m1=cls.getMethod("test",null);
String[]strs=(String[])m1.invoke(excMeth);//把Object类型的对象先还原成数组，之后才能遍历取元素
for (String string : strs) {
System.out.println(string);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果为如下（打印出了方法返回数组中的每个元素）：
1
2
三、访问属性1.通过Class对象的getField()或者getDeclaredField()方法获得指定的Field对象（根据访问修饰符确定）。这一步需要传递参数，参数为属性名。然后通过Field对象的get(Object obj)方法来访问属性，
参数Object obj表示的是属性所在的实例，即要访问哪一个对象的该属性。通过Field对象的set(Object obj)方法来设置属性，参数Object obj表示的是属性所在的实例，即要设置哪一个对象的该属性。
四。动态创建和访问数组
利用反射机制，可以动态创建数组兵访问数组，java.lang.reflect.Array类提供了创建和访问数组元素的方法，这些方法都是静态的。
综合应用实例：
package com;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Exercise {
private String name;
private int id;
public Exercise(String str){
System.out.println("在有参构造器内");
}
public String[] test(int a,int b){
String[]strs={String.valueOf(a),String.valueOf(b)};
return strs;
}
public static void main(String[] args) {
try {
//获得Class对象
Class cls=Class.forName("com.Exercise");
//通过Class对象获取构造器
Constructor con=cls.getConstructor(String.class);//注意！没加Declared则只能获取到public修饰的,这里可以用
//调用Constructor的newInstance()方法创建实例
Object e=con.newInstance("哈哈");
//通过Class对象，根据指定的方法名和参数列表获取指定的Method对象
Method m=cls.getMethod("test", Integer.TYPE,Integer.TYPE);//注意int对应的是Integer.TYPE不是Integer.class
//通过Method对象调用方法，需要传入对象和参数
String[]str=(String[])m.invoke(e, 1,2);
for (String string : str) {
System.out.println(string);
}
//通过Class对象获取指定的Field对象
Field name=cls.getDeclaredField("name");//因为属性private必须加上Declared
Field id=cls.getDeclaredField("id");//因为属性private必须加上Declared
//通过Field对象来获取指定的属性，需要传入对象
System.out.println("更改前e的属性:name="+name.get(e)+" id="+id.getInt(e));
//通过Field对象来设置指定的属性，需要传入对象
name.set(e, "zhangsan");
id.set(e, 1);
System.out.println("更改后e的属性:name="+name.get(e)+" id="+id.getInt(e));
//调用Array的静态方法动态创建一个数组，元素类型是int，长度为2
Object arr=Array.newInstance(Integer.TYPE, 2);
//调用Array的静态方法指定数组某个元素的值，参数1是数组，2是索引，3是元素值
Array.set(arr, 1, 123);
//调用Array的静态方法获取数组指定索引位置的元素。参数1是数组，2是索引
System.out.println("数组中索引为1的元素"+Array.get(arr, 1));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
运行程序，结果为：
在有参构造器内
1
2
更改前e的属性:name=null id=0
更改后e的属性:name=zhangsan id=1
数组中索引为1的元素123
注意：在获得Constructor和Method对象时，如果有参数，那么获取对象时就需要指定参数列表，尤其需要注意参数类型，如果方法中参数为基本数据类型，那么参数就是对应包装类.TYPE，引用数据类型，那么就是类名.class。比如方法声明时参数为int a,那么获取Method对象时参数要写成Integer.TYPE,如果是String str,那么那么获取Method对象时参数要写成String.class。
int.class==Integer.TYPE;true
int.class==Integer.class;false
