反射
反射什么—Class类
1. 反射就是把Java类中的各种成分映射成一个个的java对象。例如，一个类有：成员变量，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象。
2. Class类用于表示.class文件，画图演示一个对象的创建过程。
3. 如何得到某个class文件对应的class对象。
类名.class 对象.getClass() Class.forName(“类名”)
以上三种方式，JVM都会把相应class文件装载到一个class对象中(只装载一次)
public static void main(String[] args) throws Exception { //反射：加载类，获得类的字节码 //1 Class clazz=Class.forName("cn.ydj.reflect.Person"); //2 Class clazz1=new Person().getClass(); //3 Class clazz2=Person.class; }
创建类的实例：Class.newInstance方法
数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int，void…
掌握反射技术的要点在于：如何从一个class中反射出各个组成部分。反射出来的对象怎么用。
Constructor类
（1）Constructor类代表某个类中的一个构造方法
得到某个类所有的构造方法：
例子：Constructor [] constructors= Class.forName("java.lang.String").getConstructors();
得到某一个构造方法：
例子： //获得方法时要用到类型
Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
（2）创建实例对象
通常方式：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();
该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
package reflect; import java.io.InputStream; import java.util.List; public class Person { public String name="aaaa"; private int password; private static int age=23; public Person(){ System.out.println("person"); } public Person(String name){ this.name=name; System.out.println("person name"); } public Person(String name,int password){ this.name=name; System.out.println("person name password"); } private Person(List list){ System.out.println("list"); } public void aa1(){ System.out.println("aa1"); } public void aa1(String name,int password){ System.out.println("name= "+name+" password="+password); } public Class[] aa1(String name,int[] password){ return new Class[]{String.class}; } private void aa1(InputStream in){ System.out.println(in); } public static void aa1(int num){ System.out.println(num); } public static void main(String []args){ System.out.println("main"); } }
package reflect; import java.lang.reflect.Constructor; import java.util.ArrayList; import java.util.List; import org.junit.Test; //反射类的构造函数，创建类的对象 public class Demo2 { //public Person() @Test public void test1() throws Exception{ //加载.class类文件到内存中 Class clazz=Class.forName("reflect.Person"); Constructor c=clazz.getConstructor(null); System.out.println(c);//public reflect.Person() Person p=(Person) c.newInstance(null);//person System.out.println(p.name);//aaaa } //创建对象的另外一种途径，无参构造方法，等效test1 @Test public void test5() throws Exception{ Class clazz=Class.forName("reflect.Person"); Person p=(Person) clazz.newInstance(); System.out.println(p.name);//aaaa } //public Person(String name) @Test public void test2() throws Exception{ Class clazz=Class.forName("reflect.Person"); Constructor c=clazz.getConstructor(String.class); Person p=(Person) c.newInstance("abc");//person name System.out.println(p.name);//abc } //public Person(String name,int password) @Test public void test3() throws Exception{ Class clazz=Class.forName("reflect.Person"); Constructor c=clazz.getConstructor(String.class,int.class); Person p=(Person) c.newInstance("abc",999);//person name password System.out.println(p.name);//abc } //private Person(List list) @Test public void test4() throws Exception{ Class clazz=Class.forName("reflect.Person"); Constructor c=clazz.getDeclaredConstructor(List.class); c.setAccessible(true);//暴力反射，统统打开访问权限 Person p=(Person) c.newInstance(new ArrayList());//list System.out.println(p.name);//aaaa } }
Field类
Field类代表某个类中的一个成员变量
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？
所以字段fieldX 代表的是x的定义，而不是具体的x变量。(注意访问权限的问题)
示例代码：
package reflect; import java.lang.reflect.Field; import org.junit.Test; //反射类的字段 public class Demo4 { //public String name="aaaa"; @Test public void test1() throws Exception{ Class clazz=Class.forName("reflect.Person"); Field f=clazz.getField("name"); Person p=new Person(); Object value= f.get(p);//获取字段值 System.out.println(value); Class type=f.getType();//字段类型 System.out.println(type);//class java.lang.String if(type.equals(String.class)){ String S_value=(String)value; System.out.println(S_value);//aaaa } //设置值 f.set(p, "ppppp"); System.out.println(f.get(p));//ppppp System.out.println(String.class);//class java.lang.String } //private int password; @Test public void test2() throws Exception{ Class clazz=Class.forName("reflect.Person"); Field f=clazz.getDeclaredField("password"); f.setAccessible(true); Person p=new Person(); f.set(p, 123); System.out.println(f.get(p));//123 } //private static int age=23; @Test public void test3() throws Exception{ Class clazz=Class.forName("reflect.Person"); Field f=clazz.getDeclaredField("age"); f.setAccessible(true); System.out.println(f.get(null));//23 } }
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})形式。
package reflect; import java.io.FileInputStream; import java.io.InputStream; import java.lang.reflect.Method; import org.junit.Test; //反射类的方法 public class Demo3 { // public void aa1() @Test public void test1() throws Exception{ Class clazz=Class.forName("reflect.Person"); Method method=clazz.getMethod("aa1", null); Person p=new Person();//person method.invoke(p, null);//调用谁的对象的方法;方法所传递的参数 } //public void aa1(String name,int password) @Test public void test2() throws Exception{ Class clazz=Class.forName("reflect.Person"); Method method=clazz.getMethod("aa1", String.class,int.class); Person p=new Person();//person method.invoke(p, "xxxx",99);//name= xxxx password=99 } //public Class[] aa1(String name,int[] password) @Test public void test3() throws Exception{ Class clazz=Class.forName("reflect.Person"); Method method=clazz.getMethod("aa1", String.class,int[].class); Person p=new Person();//person Class cs[]=(Class[]) method.invoke(p, "xxxx",new int[]{1,2,3}); System.out.println(cs[0]);//class java.lang.String } //private void aa1(InputStream in) @Test public void test4() throws Exception{ Class clazz=Class.forName("reflect.Person"); Method method=clazz.getDeclaredMethod("aa1",InputStream.class); method.setAccessible(true); Person p=new Person();//person method.invoke(p,new FileInputStream("D:\\baibing.jpg"));// } //public static void aa1(int num) @Test public void test5() throws Exception{ Class clazz=Class.forName("reflect.Person"); Method method=clazz.getMethod("aa1",int.class); method.invoke(null,777);//777 静态方法调用不需要对象，给对象也行 } // public static void main(String []args){}//重点 @Test public void test6() throws Exception{ Class clazz=Class.forName("reflect.Person"); Method method=clazz.getMethod("main",String [].class); //method.invoke(null,new String[]{"a","c"});//Wrong //method.invoke(null,"a","c");//Wrong String []str={"x","y","z"}; method.invoke(null, (Object)str); method.invoke(null,new Object[]{new String[]{"a","c"} }); method.invoke(null, (Object)new String[]{"a","c"}); //jdk1.5 Method.invoke(Objet objecr,Object...args);用可变参数传递多个参数 //jdk.1.4 Method.invoke(Obeject objecr ,Object obj[]{"xx","yy"});用数组传递多个参数 //java需要兼容jdk1.4，就会拆除数组里的元素为多个参数，解决思路外面再加一个数组new Object[]{new String[]{}},或者(Object)new String[]{"a","c"}欺骗系统不是数组； //开发中要注意传递数组的方法 } }
用反射方式反射类中的main方法
目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的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"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
// public static void main(String []args){}//重点
@Test
public void test6() throws Exception{
Class clazz=Class.forName("reflect.Person");
Method method=clazz.getMethod("main",String [].class);
//method.invoke(null,new String[]{"a","c"});//Wrong
//method.invoke(null,"a","c");//Wrong
String []str={"x","y","z"};
method.invoke(null, (Object)str);
method.invoke(null,new Object[]{new String[]{"a","c"} });
method.invoke(null, (Object)new String[]{"a","c"});
//jdk1.5 Method.invoke(Objet objecr,Object...args);用可变参数传递多个参数
//jdk.1.4 Method.invoke(Obeject objecr ,Object obj[]{"xx","yy"});用数组传递多个参数
//java需要兼容jdk1.4，就会拆除数组里的元素为多个参数，解决思路外面再加一个数组new Object[]{new String[]{}},或者(Object)new String[]{"a","c"}欺骗系统不是数组；
//开发中要注意传递数组的方法
