java笔记（二）——反射技术

一、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 {//反射：加载类，获得类的字节码//1Class clazz=Class.forName("cn.ydj.reflect.Person");//2Class clazz1=new Person().getClass();//3Class clazz2=Person.class;}

创建类的实例：Class.newInstance方法
数组类型的Class实例对象
Class.isArray()
总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int，void…
反射就是把Java类中的各种成分映射成一个个的java对象。例如，一个类有：成员变量，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象。
掌握反射技术的要点在于：如何从一个class中反射出各个组成部分。反射出来的对象怎么用。

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");}}

二、Constructor类

（1）Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法：

例子：Constructor[] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：

例子：       //获得方法时要用到类型

 Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);      

（2）创建实例对象：

通常方式：String str = newString(new StringBuffer("abc"));

反射方式： String str =(String)constructor.newInstance(newStringBuffer("abc"));

Class.newInstance()方法：

例子：

String obj =(String)Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

//public Person()@Testpublic void test1() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Constructor c=clazz.getConstructor(null);//无参构造方法Person p=(Person) c.newInstance(null);//personSystem.out.println(p.name);//aaaa}//public Person(String name)@Testpublic void test2() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Constructor c=clazz.getConstructor(String.class);//有参构造方法Person p=(Person) c.newInstance("abc");//person nameSystem.out.println(p.name);//abc}//public Person(String name,int password)@Testpublic void test3() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Constructor c=clazz.getConstructor(String.class,int.class);//有参构造方法Person p=(Person) c.newInstance("abc",999);//person name passwordSystem.out.println(p.name);//abc}//private Person(List list)@Testpublic void test4() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Constructor c=clazz.getDeclaredConstructor(List.class);//私有的有参构造方法c.setAccessible(true);//暴力反射，统统打开访问权限Person p=(Person) c.newInstance(new ArrayList());//listSystem.out.println(p.name);//aaaa}//创建对象的另外一种途径，无参构造方法，等效test1@Testpublic void test5() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Person p=(Person) clazz.newInstance();System.out.println(p.name);//aaaa}

三、Field类

Field类代表某个类中的一个成员变量

问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，那关联的是哪个对象呢？所以字段field X 代表的是x的定义，而不是具体的x变量。(注意访问权限的问题)

示例代码：

//反射类的字段public class Demo4 {//public String name="aaaa";@Testpublic void test1() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Field f=clazz.getField("name");//反射出name字段Person p=new Person();Object value= f.get(p);//获取字段值Class type=f.getType();//字段类型System.out.println(type);//class java.lang.Stringif(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));//pppppSystem.out.println(String.class);//class java.lang.String}//private int password;@Testpublic void test2() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Field f=clazz.getDeclaredField("password");//反射出私有的name字段f.setAccessible(true);//Person p=new Person();f.set(p, 123);System.out.println(f.get(p));//123}//private static int age=23;@Testpublic void test3() throws Exception{Class clazz=Class.forName("cn.ydj.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})形式。

//反射方法public class Demo3 {//   public void aa1()@Testpublic void test1() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Method method=clazz.getMethod("aa1", null);//反射无参方法Person p=new Person();//personmethod.invoke(p, null);//aa1 调用无参方法}//public void aa1(String name,int password)@Testpublic void test2() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Method method=clazz.getMethod("aa1", String.class,int.class);// 反射有参方法Person p=new Person();//personmethod.invoke(p, "xxxx",99);//name= xxxx password=99 调用有参方法}//public Class[] aa1(String name,int[] password)@Testpublic void test3() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Method method=clazz.getMethod("aa1", String.class,int[].class);//反射有参方法Person p=new Person();//personClass cs[]=(Class[]) method.invoke(p, "xxxx",new int[]{1,2,3});//name= xxxx password=99  调用有参方法System.out.println(cs[0]);//class java.lang.String}//private void aa1(InputStream in)@Testpublic void test4() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Method method=clazz.getDeclaredMethod("aa1",InputStream.class);//反射私有方法method.setAccessible(true);Person p=new Person();//personmethod.invoke(p,new FileInputStream("C:\\1.txt"));//}//public static void aa1(int num)@Testpublic void test5() throws Exception{Class clazz=Class.forName("cn.ydj.reflect.Person");Method method=clazz.getMethod("aa1",int.class);method.invoke(null,777);//777  静态方法调用不需要对象，给对象也行}}

五、反射main方法

目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？

问题：

启动Java程序的main方法的参数是一个字符串数组，即publicstatic void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：

mainMethod.invoke(null,new Object[]{newString[]{"xxx"}});

mainMethod.invoke(null,(Object)newString[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

//public static void main(String []args){ 反射main方法@Testpublic void test6() throws Exception{Class clazz=Class.forName("cn.itcast.reflect.Person");Method method=clazz.getMethod("main",String [].class);//method.invoke(null,new String[]{"a","c"});//Wrong//method.invoke(null,"a","c");//WrongString []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"});//★}