黑马程序员_反射

------- android培训、java培训、期待与您交流！ ----------

 

一.概述

   1.反射就是把Java类中的各种成分映射成相应的java类。

      例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是

     一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包 

     等。

    信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

  2.一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象。

 

二.反射的基石—Class类

    1.java程序中的各个类属于同一个事物，描述这类事物的Java类就是Class类。

      java类用于描述一类事物的共性，该类事物有什么属性，该有什么属性，还有属性的值是什么，都是由这个类的实例对象来确定的。

   2. Class类代表Java类，它的各个实例对象又分别对应各个类在内存中的字节码，例如，Person类的字节码，Date类的字节码。

   3.一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同

     的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class类型。

   4.得到各个字节码对应的实例对象（Class类型）

    类名.class  例如：System.class;

    对象.getClass()  例如：new Date().getClass();

    Class.forName(“ 类名”) 例如：Class.forName(“类名”);

   举例：

        Class clas1=Person.class;//得到Person类的字节码。

      Class.forName(“java.lang.String”);

    得到某个类的字节码有两种情况：

      一是该类的字节码已加载到内存中，直接找到返回。

      二是虚拟机中还没有该类字节码，用类加载器进行加载，加载完成后保存在虚拟机中，同时该方法返回加载进来的字节码。

  5.九个预定义的Class实例对象

        八个基本类型和void

           int .class==Integer.TYPE;

     TYPE是Integer类的一个常量，它代表此包装类型包装的基本类型的字节码，所以和int.class是相等的。基本数据类型的字节码都可以用与之对应的包装类中的

     TYPE常量表示.

  6.数组类型的Class实例对象

         Class.isArray()

   总之，只要在源程序中出现的类型，都有各自的Class实例对象。

 代码：

package com.itheima.day1;import java.lang.reflect.Array;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;public class ReflectText {    public static void main(String[] args)throws Exception {    String str1="abc";        Class cls1=str1.getClass();    Class cls2=String.class;    Class cls3=Class.forName("java.lang.String");        System.out.println(cls1);//class java.lang.String    System.out.println(cls1==cls2);  //true    System.out.println(cls2==cls3);   //true            System.out.println(cls1.isPrimitive());     //false;  String是类，不是基本类型    System.out.println(int.class.isPrimitive());//true    System.out.println(int.class==Integer.class);  //false;  int  Integer 各有各的类 和字节码        System.out.println(int.class==Integer.TYPE);  //true   TYPE是常量，他所代表的是包装类包装的基本数据类型的字节码        System.out.println(int[].class.isPrimitive());//false;    System.out.println(int[].class.isArray());//true    }}

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

  1.一个class代表一份字节码，一个method代表字节码中的一个方法，一个construct代表字节码中的一个构造方法。

     构造方法是无序的，要靠参数去判断。

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

      Constructor[]  cons=Class.forName(“java.lang.String”).getConstructors();

   3.得到某一个构造方法：

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

  4.用不同的方式创建实例对象：

     普通方式：

       String str=new String(new StringBuffer(“abc”)); //StringBuffer对象传递给//String的构造方法，然后new一个对象。

    反射方式：

        Constructor constructor=String.class.getConstructor(StringBuffer.class);

        String str2=(String )constructor.newInstance(new StringBuffer(“abc”));

        //调用获得的方法时要用到上面相同类型的实例对象。

       Class.newInstance()方法：（找的是无参数的构造方法）

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

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

            该方法内部用到了缓存机制来保存默认构造方法的实例对象。

 

四.Field类（代表字节码中的一个成员变量）

   1.常用方法：

      getField(String name) //返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。

      getDeclaredField(String name) //返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。

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

      setAccessible(true)//暴力访问

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

   代码：   

package com.itheima.day1;public class ReflectPoint {private int x;//私有的变量public int y;//公开的变量public ReflectPoint(int x, int y) {super();this.x = x;this.y = y;} }//反射操作  package com.itheima.day1;import java.lang.reflect.Field;public class ReflectText {    public static void main(String[] args)throws Exception {    //对ReflectPoint进行反射      ReflectPoint pt1=new ReflectPoint(3,9);    Field fieldY=pt1.getClass().getField("y");       //fieldY不是对应对象身上的变量，而是类上，要用它去取某个对象对象上对应的值。    System.out.println(fieldY.get(pt1));        Field fieldX=pt1.getClass().getDeclaredField("x");      fieldX.setAccessible(true);  //暴力反射   否则会编译失败    System.out.println(fieldX.get(pt1));       ｝｝

  2.Field类练习

  代码：

package com.itheima.day1;/* * 练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的“b”变成“a” * */public class ReflectText3 {// 定义变量public String str1 = "ball";public String str2 = "basketball";public String str3 = "itcast";@Overridepublic String toString() {return str1 + ":" + str2 + ":" + str3;}}反射操作代码：    package com.itheima.day1;import java.lang.reflect.Field;public class ReflectText {    public static void main(String[] args)throws Exception {ReflectText3 rt3=new ReflectText3();changeStringValue(rt3);           System.out.println(rt3);    }public static void changeStringValue(Object obj) throws Exception {Field[] fields = obj.getClass().getFields();for (Field field : fields) {// 这里应该用==，因为是同一份字节码if (field.getType() == String.class) {String oldValue = (String) field.get(obj);String newValue = oldValue.replace("b", "a");field.set(obj, newValue);       } }    }    }

五.Method类（代表某个类中的一个成员方法）

    1.方法：

        getMethod(String name, Class<?>... parameterTypes) //返回一个 Method对//象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。

        getMethods() //返回一个包含某些 Method对象的数组，这些对象反映此 Class //对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超

                           //接口继承的那些的类或接口）的公共 member 方法。

       Method getDeclaredMethod(String name, Class<?>... parameterTypes)

         //返回一个 Method对象，该对象反映此 Class 对象所表示的类或接口的指定//已声明方法。

       getDeclaredMethods()

            //返回 Method对象的一个数组，这些对象反映此 Class 对象表示的类或接口//声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包

          //括继承的方法。

        Object     invoke(Object obj, Object... args)

         //对带有指定参数的指定对象调用由此 Method对象表示的底层方法。

        //如果Method对象对应的是一个静态方法，方法的参数为null。

  2.得到类中的某一个方法：

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

  3.调用方法：

      普通方式：str.charAt();

      反射方式：charAt.invoke(str,1);

  4.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})形式。

   5.用反射方式执行某个类中的main方法：

        String  startingClassName=args[0];

        Method mainMethod=Class.forName(startingClassName).getMethod(“main”,String[].calss);

       在使用Method对象调用invoke()方法时，会出现问题：

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

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

六.数组的反射

   1.每个数组的父类都是Object。

   2.具有相同维数的和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

   3.代表数组的Class实例对象的getSuperClass()方法返回的父类为Object对应的Class。

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

      使用。

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

    问题：怎样得到数组中的元素类型？

     不可以的，只能得到数组中某一个元素的类型。

          Object[] a=new Object-={“a”,1};

          a[0].getClass().getName();

    注意：

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

        制转换成String x = “abc”。

 代码：

package com.itheima.day1;import java.lang.reflect.Array;import java.util.Arrays;public class ReflectArray {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 = new String[] { "a", "b", "c" };System.out.println(a1.getClass() == a2.getClass());// trueSystem.out.println(a1.getClass().getName());// [ISystem.out.println(a1.getClass().getSuperclass().getName());// java.lang.ObjectSystem.out.println(a4.getClass().getSuperclass().getName());// java.lang.Object// Object[] aobj=a1;//基本数据类型的一维数组不能转换成为Object数组。Object[] aobj2 = a3;Object[] aobj3 = a4;//String数组中的元素属于Object System.out.println(a1);// [[e-mail](a4);// [Ljava.lang.String;@1fb8ee3// Arrays.asList()方法处理int[]和String[]时的差异。System.out.println(Arrays.asList(a1));// [[I@de6ced]System.out.println(Arrays.asList(a4));// [a, b, c]Object obj = null;printObject(a1);// 1 2 3printObject("xyz");// xyz}//反射操作private static void printObject(Object obj) {Class cla = obj.getClass();if (cla.isArray()) {int len = Array.getLength(obj);for (int i = 0; i < len; i++) {System.out.println(Array.get(obj, i));}} else {System.out.println(obj);}}}

七.反射的作用-实现框架功能

    1.框架：框架就是可重复用的设计构件。

     举例：房地产开发商建房子卖给用户住，由用户自己安装门窗和空调，房地产开发商做的房子就是框架，用户需要使用框架，把门窗安装到提供的框架中。

    2.框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

    3.框架要解决的核心问题

       因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。

    4.路径

      在实际开发中不使用相对路径。

      一定要用完整的路径，但是完整的路径不是硬编码，而是运算出来的。

   5.Myeclipse会将源程序中的所有.java文件编译成.class文件，然后放到classPath指定的目录中去。而且会将配置文件自动的复制到classPath指定的目录中去。

  6.实现框架功能

     首先直接在工程中创建一个配置文件，文件名：config.properties

     文件的内容:classname=java.util.ArrayList

   代码：

  package com.itheima.day1;import java.io.FileInputStream;import java.io.InputStream;import java.util.Collection;import java.util.Collections;import java.util.Properties;     public class ReflectText4 {public static void main(String[] args) throws Exception{//创建文件读取流，并与配置文件关联    使用相对路径//InputStream ips=new FileInputStream("config.properties");/*用类加载器的方式管理资源和配置文件    一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。*///InputStream ips=ReflectText4.class.getClassLoader().getResourceAsStream("com/itheima/day1/config.properties");//Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件(在包中建立子包，将配置文件放到该子包中)//InputStream ips=ReflectPoint.class.getResourceAsStream("resource/config.properties");  //相对路径InputStream ips=ReflectPoint.class.getResourceAsStream("/com/itheima/day1/resource/config.properties"); //绝对路径       Properties props=new Properties();props.load(ips);//加载流ips.close();//释放资源String className=props.getProperty("className");Collection collections=(Collection) Class.forName(className).newInstance();//用反射创建Collection对象//创建ReflectPoint对象ReflectPoint pt1=new ReflectPoint(3, 3);ReflectPoint pt2=new ReflectPoint(5, 5);ReflectPoint pt3=new ReflectPoint(3, 3);//添加对象       collections.add(pt1);       collections.add(pt2);       collections.add(pt3);       collections.add(pt1);    System.out.println(collections.size());//得到打印结果:4  }}

------- android培训、java培训、期待与您交流！ ----------