Java--反射学习

 Java--反射学习

反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。

 

反射的好处：大大的增强了程序的扩展性。

 

反射的基本步骤：

1、获得Class对象，就是获取到指定的名称的字节码文件对象。

2、实例化对象，获得类的属性、方法或构造函数。

3、访问属性、调用方法、调用构造函数创建对象。

★反射的基石——Class类

1、所有的类文件都有共同属性，所以可以向上抽取，把这些共性内容封装成一个类，这个类就叫Class（描述字节码文件的对象）。Class类中就包含属性有field（字段）、method（方法）、construction（构造函数）。

 而field中有修饰符、类型、变量名等复杂的描述内容，因此也可以将字段封装称为一个对象。用来获取类中field的内容，这个对象的描述叫Field。同理方法和构造函数也被封装成对象Method、Constructor。要想对一个类进行内容的获取，必须要先获取该字节码文件的对象。该对象是Class类型。

       Class类描述的信息：类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表等。每一个字节码就是class的实例对象。如：classcls=Data.class;

小知识：什么叫字节码？

   当源程序中用到类时，首先要从硬盘把这个类的那些二进制代码，一个类编译成class放在硬盘上以后，就是一些二进制代码，要把这些二进制代码加载到内存中里面来，再用这些字节码去复制出一个一个对象来。

2、Class和class的区别

       1）class：Java中的类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则由此类的实例对象确定，不同的实例对象有不同的属性值。

       2）Class：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类，这些类称为Class。例如人对应的是Person类，Java类对应的就是Class。Class是Java程序中各个Java类的总称；它是反射的基石，通过Class类来使用反射。

 

获取这个Class对象，有三种方式：

1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。

如：Classclazz=new Person().getClass();//Person是一个类名

不足之处：每次都需要具体的类和该类的对象，以及调用getClass方法。

2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。

如：Classclazz=Person.class;//Person是一个类名

比第一种较为简单，不用创建对象，不用调用getClass方法，但是还是要使用具体的类，和该类中的一个静态属性class完成。

   

3：使用的Class类中的方法，静态的forName方法。

前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。

    指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。

// 1. 根据给定的类名来获得 用于类加载

Stringclassname = "cn.itcast.reflect.Person";// 来自配置文件

Classclazz = Class.forName(classname);// 此对象代表Person.class

// 2. 如果拿到了对象，不知道是什么类型  用于获得对象的类型

Objectobj = new Person();

Classclazz1 = obj.getClass();// 获得对象具体的类型

// 3. 如果是明确地获得某个类的Class对象 主要用于传参

Classclazz2 = Person.class; 

4、Class类中的方法

       1、static Class forName(StringclassName)

        返回与给定字符串名的类或接口的相关联的Class对象。

       2、Class getClass()

        返回的是Object运行时的类，即返回Class对象即字节码对象

       3、 ConstructorgetConstructor()

        返回Constructor对象，它反映此Class对象所表示的类的指定公共构造方法。

       4、Field getField(Stringname)

        返回一个Field对象，它表示此Class对象所代表的类或接口的指定公共成员字段。

       5、Field[] getFields()

        返回包含某些Field对象的数组，表示所代表类中的成员字段。

       6、MethodgetMethod(String name,Class… parameterTypes)

        返回一个Method对象，它表示的是此Class对象所代表的类的指定公共成员方法。

       7、Method[] getMehtods()

        返回一个包含某些Method对象的数组，是所代表的的类中的公共成员方法。

       8、String getName()

        以String形式返回此Class对象所表示的实体名称。

       9、String getSuperclass()

        返回此Class所表示的类的超类的名称

       10、boolean isArray()

        判定此Class对象是否表示一个数组

       11、boolean isPrimitive()

        判断指定的Class对象是否是一个基本类型。

       12、T newInstance()

        创建此Class对象所表示的类的一个新实例。

5、通过Class对象获取类实例

        通过查看API我们知道，Class类是没有构造方法的， 因此只能通过方法获取类实例对象。之前我们用的已知类，创建对象的做法：

       1）查找并加载XX.class文件进内存，并将该文件封装成Class对象。

       2）再依据Class对象创建该类具体的实例。

       3）调用构造函数对对象进行初始化。

            如：Person p=new Person();

 现在用Class对象来获取类实例对象的做法：

       1）查找并加载指定名字的字节码文件进内存，并被封装成Class对象。

       2）通过Class对象的newInstance方法创建该Class对应的类实例。

       3）调用newInstance()方法会去使用该类的空参数构造函数进行初始化。

            如：     

                    String className="包名.Person";                    Class clazz=Class.forName(className);                     Objectobj=clazz.newInstance();

反射的用法：

1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式：

         Class.forName(classname)    用于做类加载

         obj.getClass()                            用于获得对象的类型

         类名.class                            用于获得指定的类型，传参用

 

2)、反射类的成员方法：

         Class clazz = Person.class;

         Method method =clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2});

         method.invoke();

        

3)、反射类的构造函数：

         Constructor con =clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...})

         con.newInstance(params...)

 

4)、反射类的属性：

         Field field =clazz.getField(fieldName);

         field.setAccessible(true);

         field.setObject(value);

 

获取了字节码文件对象后，最终都需要创建指定类的对象：

创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)：

1，调用空参数的构造函数：使用了Class类中的newInstance()方法。

2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。

 

综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。

------------------------------------------------------

  

 // 如何生成获取到字节码文件对象的实例对象。        Classclazz = Class.forName("cn.itcast.bean.Person");//类加载// 直接获得指定的类型        clazz= Person.class;        // 根据对象获得类型        Objectobj = new Person("zhangsan", 19);        clazz= obj.getClass();         Object obj = clazz.newInstance();//该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2();    publicstatic void method_2() throws Exception {        Class clazz =Class.forName("cn.itcast.bean.Person");        //既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。        //获取一个带参数的构造器。        Constructor constructor = clazz.getConstructor(String.class,int.class);        //想要对对象进行初始化，使用构造器的方法newInstance();        Object obj =constructor.newInstance("zhagnsan",30);        //获取所有构造器。        Constructor[]constructors = clazz.getConstructors();//只包含公共的        constructors =clazz.getDeclaredConstructors();//包含私有的        for(Constructor con : constructors) {            System.out.println(con);        }    }

------------------------------------------------------

反射指定类中的方法：    //获取类中所有的方法。    publicstatic void method_1() throws Exception {        Class clazz =Class.forName("cn.itcast.bean.Person");        Method[]methods = clazz.getMethods();//获取的是该类中的公有方法和父类中的公有方法。        methods = clazz.getDeclaredMethods();//获取本类中的方法，包含私有方法。        for(Method method : methods) {            System.out.println(method);        }    }    //获取指定方法；    publicstatic void method_2() throws Exception {        Class clazz =Class.forName("cn.itcast.bean.Person");        //获取指定名称的方法。        Method method =clazz.getMethod("show", int.class,String.class);        //想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。        Object obj = clazz.newInstance();        method.invoke(obj,39,"hehehe");//执行一个方法    }    //想要运行私有方法。    publicstatic void method_3() throws Exception {        Class clazz =Class.forName("cn.itcast.bean.Person");        //想要获取私有方法。必须用getDeclearMethod();        Method method =clazz.getDeclaredMethod("method", null);        // 私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。        method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。    }    //反射静态方法。    publicstatic void method_4() throws Exception {        Class clazz = Class.forName("cn.itcast.bean.Person");        Method method =clazz.getMethod("function",null);        method.invoke(null,null);    }

示例：第一个示例

package ab.wkq;import java.lang.reflect.Field;public class ReflectClassDemo {       public staticvoid main(String[] args) throws Exception {              createPersonClass();              getPersonField();       }        // 通过Class对象创建类实例方法       public staticvoid createPersonClass() throws Exception {              // 获取Person类的Class对象              StringclassName = "ab.wkq.Person";              Classclazz = Class.forName(className);              // 通过newInstance方法获取类的无参构造函数实例              Personp = (Person) clazz.newInstance();       }} package ab.wkq; public class Person { //Person类       private String name;       public intage;        public Person() {              System.out.println("李四 "+"---"+29);       }        public Person(String name, int age) {              this.age =age;              this.name =name;       }        public String toString() {              return name+ ":" + age;       }       @Override   public String toString() {      return  name + ","+ age;   }}

Constructor类

1、概述

        如果指定的类中没有空参数的构造函数，或者要创建的类对象需要通过指定的构造函数进行初始化。这时怎么办呢？这时就不能使用Class类中的newInstance方法了。既然要通过指定的构造函数进行对象的初始化。就必须先获取这个构造函数——Constructor。Constructor代表某个类的构造方法。

2、获取构造方法：

       1）得到这个类的所有构造方法：如得到上面示例中Person类的所有构造方法

             Constructor[] cons = Class.forName(“cn.itheima.Person”).getConstructors();

       2）获取某一个构造方法：

             Constructor con=Person.class.getConstructor(String.class,int.class);

3、创建实例对象：

        1）通常方式：Personp = new Person(“lisi”,30);

        2）反射方式：Person p= (Person)con.newInstance(“lisi”,30);

注：

        1、创建实例时newInstance方法中的参数列表必须与获取Constructor的方法getConstructor方法中的参数列表一致。

        2、newInstance()：构造出一个实例对象，每调用一次就构造一个对象。

        3、利用Constructor类来创建类实例的好处是可以指定构造函数，而Class类只能利用无参构造函数创建类实例对象。

例如：

package ab.wkq;import java.lang.reflect.Constructor;public class ReflectClassDemo2{       public staticvoid main(String[] args) throws Exception {              createPersonClass();       }        // 通过Class对象创建类实例方法       public staticvoid createPersonClass() throws Exception {              // 获取Person类的Class对象              StringclassName = "ab.wkq.Person";              Classclazz = Class.forName(className);                            //获取指定构造函数的类实例               Constructorcon=clazz.getConstructor(String.class,int.class);              // 通过newInstance方法获取类的无参构造函数实例                           Personp = (Person) con.newInstance("lisi",27);              System.out.println(p.toString());        }}

Field类

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

2、方法

       FieldgetField(String s);//只能获取公有和父类中公有

       Field getDeclaredField(String s);//获取该类中任意成员变量，包括私有

       setAccessible(ture);

       //如果是私有字段，要先将该私有字段进行取消权限检查的能力。也称暴力访问。

       set(Object obj, Object value);//将指定对象变量上此Field对象表示的字段设置为指定的新值。

        Objectget(Object obj);//返回指定对象上Field表示的字段的值。

示例：依据第一个示例

//获取Person对象的成员变量        publicstaticvoid getPersonField() throws Exception{           //如果想要给该变量赋值，必须先要有对象。            Class clazz=Class.forName("ab.wkq.Person");            Person p=(Person)clazz.newInstance();                            //获取所以的成员变量            Field[] fs=clazz.getFields();            for(Field f:fs){                System.out.println(f);            }                            //获取指定的成员变量            Field fage=clazz.getField("age");            Field fname=clazz.getDeclaredField("name");                            //显示改变后的值            fage.set(p, 20);            System.out.println(fage.get(p));                            //暴力访问私有变量            fname.setAccessible(true);            fname.set(p, "lisi");            System.out.println(fname.get(p));        }  

五、Method类

1、概述：Method类代表某个类中的一个成员方法。调用某个对象身上的方法，要先得到方法，再针对某个对象调用。

2、专家模式：谁调用这个数据，就是谁在调用它的专家。

如人关门：

        调用者：是门调用关的动作，对象是门，因为门知道如何执行关的动作，通过门轴之类的细节实现。

        指挥者：是人在指挥门做关的动作，只是给门发出了关的信号，让门执行。

        总结：变量使用方法，是方法本身知道如何实现执行的过程，也就是“方法对象”调用方法，才执行了方法的每个细节的。

3、方法

       Method[] getMethods();//只获取公共和父类中的方法。

       Method[] getDeclaredMethods();//获取本类中包含私有。

       Method   getMethod("方法名"，参数.class（如果是空参可以写null）);

       Object invoke(Object obj ,参数);//调用方法

        如果方法是静态，invoke方法中的对象参数可以为null。

如：

获取某个类中的某个方法：（如String str =”abc”）

       1）通常方式：str.charAt(1)

       2）反射方式：

                                 Method charAtMethod =Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);

                                 charAtMethod.invoke(str,1);

说明：如果传递给Method对象的invoke()方法的第一个参数为null，说明Method对象对应的是一个静态方法

4、用反射方式执行某个main方法：

        首先要明确为何要用反射：在写源程序时，并不知道使用者传入的类名是什么，但是虽然传入的类名不知道，而知道的是这个类中的方法有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,newObject[]{new String[]{"xxx"}});

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

        这两种方式编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。

例如：依据第一个示例

publicstaticvoid main(String[] args) throwsException {              createPersonClass();              getPersonField();                                        Class clazzs=Class.forName("ab.wkq.Person");           Person p=(Person)clazzs.newInstance();                            Method[] mes=clazzs.getMethods();//只获取公共的和父类中的。           //mes=clazz.getDeclaredMethods();//获取本类中包含私有。           for(Method me:mes){               System.out.println(me);           }           Person ps = new Person("hehe",20);          //获取单个方法           Method me=clazzs.getMethod("toString", null);           Object returnVaule=me.invoke(ps, null);           System.out.println(returnVaule);                    }

例如：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。

package ab.wkq; importjava.lang.reflect.Method; public class PerformedMain {         publicstatic voidmain(String[] args) throws Exception{         //普通方式         Test.main(new String[]{"wkq","qb","754"});         System.out.println("-----------------------------");                          //反射方式         String className=args[0];         Class clazz=Class.forName(className);                          Method methodMain=clazz.getMethod("main",String[].class);         //方式一：强制转换为超类Object，不用拆包         methodMain.invoke(null, (Object)newString[]{"wkq","qb","754"});         //方式二：将数组打包，编译器拆包后就是一个String[]类型的整体          methodMain.invoke(null, newObject[]{new String[]{"wkq","qb","754"}});     } }class Test {          publicstatic voidmain(String[] args) {                     //System.out.println(args[0]+"---");                     for(Stringarg : args){                      System.out.println(arg);                 }          } }

注：此示例用eclipse运行时，需要在Run As——>RunConfigurations——>Arguments——>Program arguments中添加要执行的类名，如：ab.wkq.Test

例如：

packageab.wkq; importjava.io.File; importjava.io.FileInputStream; importjava.util.Properties;  public classReflectTest {      public static void main(String[] args)throws Exception{                  /*         *笔记本电脑使用usb设备          */                   NoteBook computer=new NoteBook();         computer.run();                  //关联配置文件         File file=newFile("usb.properties");         FileInputStream fis=newFileInputStream(file);         //将配置文件信息缓存到集合中         Properties ps=new Properties();         ps.load(fis);         //System.out.println(ps.size());         for(int x=1;x<=ps.size();x++){             StringclassName=ps.getProperty("usb"+x);//获取配置文件中类名             Classclazz=Class.forName(className);//获取类的Class对象             USB usb=(USB)clazz.newInstance();//得到类实例             computer.useUSB(usb);//开始使用                      }         fis.close();//关流     } }  //USB 接口  interface USB {     void open();     void close(); } //笔记本电脑  class NoteBook {     public void run(){         System.out.println("NoteBook isrun");     }          public void useUSB(USB usb){         if(usb!=null){             usb.open();             usb.close();         }     } } //鼠标  class MouseUSB implements USB {     @Override     public void open() {         System.out.println("Mouse isuse");     }     @Override     public void close() {         System.out.println("Mouse isclose");     } } //键盘  class KeyUSB implements USB {     @Override     public void open() {         System.out.println("Key isuse");     }     @Override     public void close() {         System.out.println("Key isclose");     } }  

六、数组的反射

1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。数组字节码的名字：有[和数组对应类型的缩写，如int[]数组的名称为：[I

2、Object[]与String[]没有父子关系，Object与String有父子关系，所以new Object[]{“aaa”,”bb”}不能强制转换成newString[]{“aaa”,”bb”}; Object x =“abc”能强制转换成Stringx =“abc”。

3、如何得到某个数组中的某个元素的类型，

       例：

              int a= new int[3]；Object[] obj=newObject[]{”ABC”,1};

        无法得到某个数组的具体类型，只能得到其中某个元素的类型，

       如：

               Obj[0].getClass().getName()得到的是java.lang.String。

4、Array工具类用于完成对数组的反射操作。

       Array.getLength(Object obj);//获取数组的长度

       Array.get(Object obj,int x);//获取数组中的元素

5、基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

示例：

package ab.wkq importjava.lang.reflect.Array;import java.util.Arrays; public classArrayReflect {         public static void main(String[] args) {                   int [] a1 = new int[]{1,2,3};                   int [] a2 = new int[4];                   int[][] a3 = new int[2][3];                   String [] a4 = newString[]{"a","b","c"};                   System.out.println(a1.getClass().equals(a2.getClass()));//true         System.out.println(a1.getClass().equals(a3.getClass()));//false         System.out.println(a1.getClass().equals(a4.getClass()));//false         System.out.println(a1.getClass().getName());//[I         System.out.println(a4.getClass().getName());//[Ljava.lang.String;         System.out.println(a1.getClass().getSuperclass());//classjava.lang.Object         System.out.println(a4.getClass().getSuperclass());//classjava.lang.Object                                     Object obj1=a1;                   Object obj2=a3;                   Object obj3=a4;                  //               Object[] obj11=a1;//这样是不行的，因为a1中的元素是int类型，基本数据类型不是Object                   Object[] obj13=a3;                   Object[] obj14=a4;//这样可以，因为String数组中的元素属于Object                                     System.out.println(a1);//[I@4caaf64e                   System.out.println(a4);//[Ljava.lang.String;@6c10a234                   System.out.println(Arrays.asList(a1));//[I@4caaf64e                   System.out.println(Arrays.asList(a4));//[a, b, c]                                     /* Arrays.asList()方法处理int[]和String[]时的差异。                    * 打印Arrays.asList(a1);还是跟直接打印a1是一样的                            打印Arrays.asList(a4);就会把a3的元素打印出来。                            这是因为此方法在JDK1.4版本中，接收的Object类型的数组，                            而a3可以作为Object数组传入。但是a1不可以作为Object数组传入，所以只能按照JDK1.5版本来处理。                            在JDK1.5版本中，传入的是一个可变参数，所以a1就被当作是一个object，也就是一个参数，                            而不是数组传入，所以打印的结果还是跟直接打印a1一样。                    */                                     //Array工具类用于完成对数组的反射操作。如打印任意数值                   printObject(a1);                   printObject(a4);                   printObject("abc");                           }         //打印任意数值         private static void printObject(Object obj) {                   Class clazz=obj.getClass();                   //如果传入的是数组，则遍历                   if(clazz.isArray()){                            int len =Array.getLength(obj);//Array工具类获取数组长度方法                            for(int x=0;x<len;x++){                                     System.out.println(Array.get(obj,x));//Array工具获取数组元素                            }                   }                   else                            System.out.println(obj);         }}

练习--------------通过反射修改数组大小

package ab.wkq;import java.lang.reflect.Array;public class ReflectArr { public static void main(String[] args) {        int[] temp={1,2,3,4,5,6,7,8,9};        int[] newTemp=(int[])arrayInc(temp,15);        print(newTemp);        System.out.println("=====================");        String[] atr={"a","b","c"};        String[] str1=(String[])arrayInc(atr,8);        print(str1);    }         /**     * 修改数组大小     * */    public static Object arrayInc(Object obj,int len){        Class<?>arr=obj.getClass().getComponentType();        Object newArr=Array.newInstance(arr, len);        int co=Array.getLength(obj);        System.arraycopy(obj, 0, newArr, 0, co);        return newArr;    }    /**     * 打印     * */    public static void print(Object obj){        Class<?>c=obj.getClass();        if(!c.isArray()){            return;        }        System.out.println("数组长度为： "+Array.getLength(obj));        for (int i = 0; i < Array.getLength(obj); i++) {            System.out.print(Array.get(obj, i)+" ");        }    }}