Java学习提高：反射（*重点*）

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

一、Class类

  1、概念：Class是Java程序中各个Java类的总称，一个Class对象代表一个Java类的字节码文件它是反射的基石， 

             通过Class类 来使用反射。

   2、Class类中的元素：类名，类的访问属性，类所属包名，字段名称列表，方法名称列表等。

   3、Class和class的区别

          class：Java中的类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，

                   则由此类的实例对象确定，不同的实例对象有不同的属性值。

          Class：指的是Java程序中的各个Java类是属于同一类事物，都是Java程序的类的字节码对象，这些类称为Class。 

                  例如人对应的是Person类，Java类对应的就是Class。

   4、如何获取Class实例对象？

         不可用new Class()的方式，因为Class没有这样的构造方法。而是将字节码对象赋值给Class变量。 

          如Class c1 =Person.class。

                  如Person类，它的字节码：首先要将Person的java文件编译为class文件放于硬盘上，即为二进制代码，再将 

          这些代码加载到内存中，接着用它创建一个个对象。就是把类的字节码加载进内存中，再用此字节码创建一个个 

          对象。当有如Person、Math、Date等等的类，那么这些字节码就是分别的一个Class对象。即Class c2=Date.class;

   5、获取各个字节码对应的实例对象的方法

          类名.class，例如，System.class; 

          对象.getClass()，例如，new Date().getClass() 

          Class.forName("类名")，例如，Class.forName("java.util.Date");

   6、Class.forName(java.lang.String)的作用（面试题）

         获取字符串类的字节码文件String.class。得到这个字节码对象有两种情况：

      （1）此类已经加载进内存：若要得到此类字节码，不需要再加载。

      （2）此类还未加载进内存：类加载器加载此类后，将字节码缓存起来，forName()方法返回加载进来的字节码。

   7、九个预定义的Class：

      （1）包括八种基本类型（byte、short、int、long、float、double、char、boolean）的字节码对象和一种 

                返回值为void类型的void.class。

     （2）Integer.TYPE是Integer类的一个常量，它代表此包装类型包装的基本类型的字节码，所以和int.class是相等的。

            基本数据类型（可用isPrimitive方法判断）的字节码都可以用与之对应的包装类中的TYPE常量表示

            数组类型的Class实例对象，可以用Class.isArray()方法判断是否为数组类型的。

    总结：  总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…

 

 

    8、Class类中的常用方法

 a、static Class forName(String className)

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

 b、Class getClass()

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

c、Constructor getConstructor()

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

d、Field getField(String name)

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

e、Field[] getFields()

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

f、Method getMethod(String name,Class… parameterTypes)

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

g、Method[] getMehtods()

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

h、String getName()

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

i、String  getSuperclass()

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

j、boolean isArray()

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

k、boolean isPrimitive()

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

l、T newInstance()

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

 

二、反射概述

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

          例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法， 

          包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。

   2、类的成分：表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符， 

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

   3、  一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以 

          得到这些实例对象后，再通过这些实例对象使用它们对应成员的功能。

三、Constructor类

  1、概念：Constructor类代表某个类中的一个构造方法

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

             Constructor [] constructors= Class.forName(String 类名).getConstructors(); 

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

             Constructor constructor = Class.forName(String 类名).getConstructor(Class 参数类型); 

         注：获得方法时要用到类型 

  4、创建实例对象： 

           通常方式：String str = new String(实参);  

           反射方式： String str = (String)constructor.newInstance(实参);//实参反射时传入的类的实例对象。 

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

   5、直接通过类对应的Class对象创建该类对象：Class类中的newInstance方法 

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

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

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

 

四、Field类

   1、概念：Field类代表某个类中的一个成员变量。

   2、示例：下面是是一个对Point类使用反射获取其成员变量的示例。

 /*创建一个Point类*/
 public class ReflectPoint {  
    private int x;  
    public int y;  
  
    public String toString(){  
        return str1+";" + str2 + ";" + str3;  
    }  
}  
 
 /*对Point类使用反射获取其成员变量*/
 public class FieldTest(){  
ReflectPoint pt1 = new ReflectPoint(3,5);  
    	//fieldY的值是多少？是5,错！fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值  
    	//要用它去取某个对象上的对应的值，传入什么对象，就取相应对象的值。  
    	Field fieldY = pt1.getClass().getField("y");  
    	System.out.println(fieldY.get(pt1));  
    	//获取私有的成员变量  
Field fieldX = pt1.getClass().getDeclaredField("x");  
    	fieldX.setAccessible(true);  
    	System.out.println(fieldX.get(pt1));  
}  

 总结：

     1、获取成员变量：

如上例子所示：

         （1）获取公有的成员变量：

               getField(String name)和get(变量)

         （2）获取私有的成员变量：暴力反射

               getDeclared(String name)

               setAccessible(boolean b)，将b设为true即可

               变量.get(变量所属对象)

 

    2、对字节码的比较用等号。

         因为内存中同一类型的字节码文件只有一份。

 

 

 

 3、练习：下面代码实现了将传入的参数字符串中的字符'b‘替换成字符'a'。

 

/**
  * 将传入的参数字符串中的字符'b‘替换成字符'a'
  * @param obj:要被替换的字符串对象
  */
 private 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); //记得替换后设置到对象中 
        }  
    }  
}  
 

   注意：记得将替换后的结果通过set方法设置到对象中。

 

五、Method类

 1、概念：Method类代表某个类中的一个成员方法。

      调用某个对象身上的方法，要先得到方法，再针对某个对象调用。

 2、专家模式：谁拥有这个数据，谁就是根据这个数据实现功能的专家。

     如人关门：

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

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

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

       了方法的每个细节的。

  3、获取某个类中的某个方法：（如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。

 

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

  反射的作用：

       在写源程序时，并不知道使用者传入的类名是什么，但是虽然传入的类名不知道，而知道的是这个类中的方法有main这个方法，所以可以通过反射的方式，通过使用者传入的类名（可定义字符串型变量作为传入类名的入口，通过这个变量代表类名），内部通过传入的类名获取其main方法，然后执行相应的内容。

 

   下面是用反射执行main方法的代码演示

 private static void methodTest(String [] args) throws Exception {  
    String str1 = "abc";  
    //一般方法：  
    System.out.println(str1.charAt(1));  
    //反射方法 ：  
    Method methodCharAt =  
        Class.forName("java.lang.String").getMethod("charAt",int.class);  
    System.out.println(methodCharAt.invoke(str1,1));  
      
    //用反射方式执行某个main方法  
    //一般方式：  
    Test.main(new String[]{"111","222","333"});  
    System.out.println("-------");  
      
    //反射方式：  
    String startingClassName = args[0];  
    Method methodMain =  
        Class.forName(startingClassName).getMethod("main",String[].class);  
        //方案一：强制转换为超类Object，告诉JVM传入参数是一个对象，不用拆包  
        methodMain.invoke(null,(Object)new String[]{"111","222","333"});  
        //方案二：将数组打包，编译器拆包后就是一个String[]类型的整体  
        methodMain.invoke(null,new Object[]{new String[]{"111","222","333"}});  
    }  
 
//定义一个用于测试类  
class Test{  
    public static void main(String [] args){  
        for(String arg : args){  
            System.out.println(arg);  
        }  
    }  
} 
 

七、数组的反射

  1、具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。

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

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

     既可以当做Object类型使用，又可以当做Object[]类型使用。 

   例如：定义以下四个数组：

 

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

 

       以下四个赋值：

 

        Object aObj1 = a1; //合法

        Object aObj2 = a4; //合法 

        Object[] aObj3 = a1; //不合法，a1里面元素是基本数据类型，不能当做Object对象

        Object[] aObj4 = a3; //合法，转成Object[]类型数组后，数组中元素是一维数组。

        Object[] aObj5 = a4; //合法

 

   4、Arrays.asList()方法处理int[]和String[]时的差异

     int[]类型数组作为参数时，因为该类型不属于Object[]类型，也不是其子类，所以JDK1.4版本处理不了。

     在JDK1.5里面会将传入的int[]型数组当成一个参数处理。

     当参数是String[]类型的数组时，JDK1.4版本的特性，会将参数当成一个数组处理，进行拆包，取里面

     的元素作为参数。

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

       通过定义一个打印功能演示

 

 

/**
 
  * 通过判断传入的对象将其打印，如果是数组，逐个打印其元素；若不是数组，直接打印。
 
  * @param obj 要打印的对象
 
  */
 
 private static void printObject(Object obj) {
  	Class clazz = obj.getClass();
  	if(clazz.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);
  	}
 
 }
 
 

八、HashSet和与hashCode的分析

 1、HashSet的特点：HashSet是一个集合容器，底层是哈希数据结构，元素不能重复，增删快，查询慢。

 2、HashSet如何保证元素的唯一性？

     元素的重复与否是先判断哈希值是否相同，若相同再根据equals方法判断元素是否相同。

     所以可以复写hashCode方法和equals方法。

  注：只有存入的是具有hashCode算法的集合的，覆写hashCode()方法才有价值。

 3、哈希算法的由来：

    若在一个集合中查找是否含有某个对象，通常是一个个的去比较，找到后还要进行equals的比较，

    对象特别多时，效率很低，通过哈希算法，将集合分为若干个区域，每个对象算出一个哈希值，

    可将哈希值分组（一般模32为一组），每组对应某个存储区域，依一个对象的哈希码即可确定此对象

    对应区域，从而减少每个对象的比较，只需在指定区域查找即可，从而提高从集合中查找元素的效率。

    示意图：

 4、如果不存入是hashCode算法的集合中，那么则不用复写此方法。

 3、只有类的实例对象要被采用哈希算法进行存入和检索时，这个类才需要按要求复写hashCode()方法，

    即使程序可能暂时不会用到当前类的hashCode()方法，但是为提供一个hashCode()方法也不会

    有什么不好，没准以后什么时候就会用到这个方法，所以通常要求hashCode()和equals()两者一

    并被覆盖。

 6、提示：

   （1）若同类两对象用equals()方法比较的结果相同时，他们的哈希码也必须是相等的，但反过来就

       不成立了，如”BB”和”Aa”两字符串用equals()比较式不相等的，但是他们的哈希值是相等的。

   （2）当一个对象被存储进HashSet集合中，就不能再修改参与计算哈希值的字段，否则对象被修改后

       的哈希值与最初被存入的HashSet集合中的哈希值就不同了。在这种情况下，即使contains()

       方法是用对象的当前引用作为参数去HashSet集合中检索对象，也将返回找不到对象的结果，这

        也导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露。

   简单说，之前存入的对象和修改后的对象，是具有不同的哈希值，被认为是不同的两个对象，这样的对象

     不再使用，又不移除，而越来越多，就会导致内存泄露。

  拓展：用HashSet集合存储元素后，修改了用于计算hashCode值的参数，那么再去访问元素时会发生内存泄漏， 

       找不到要访问的元素。

    内存泄漏：内存中的某个数据不需要再使用了，但是该数据还存在着内存中，没有释放内存空间。

九、反射的作用——>实现框架功能

 1、框架：通过反射调用位置Java类的一种方式。

     如房地产商造房子用户住，门窗和空调等等内部都是由用户自己安装，房子就是框架，用户需使用

     此框架，安好门窗等放入到房地产商提供的框架中。

   框架和工具类的区别：工具类被用户类调用，而框架是调用用户提供的类。

 2、框架机器要解决的核心问题：

     我们在写框架（造房子的过程）的时候，调用的类（安装的门窗等）还未出现，那么，框架无法知

     道要被调用的类名，所以在程序中无法直接new其某个类的实例对象，而要用反射来做

 3、简单框架程序的步骤：

   （1）右击项目名-->File-->命名，写入键值对：className=java.util.ArrayList，等号右边

       的可以自己定义集合的名称，即用户可以对此记事本修改成自己的类名。

   （2）代码实现，加载此文件：

       ①将文件读取到读取流中，一定要用完整的路径，可以使用getRealPath()方法获取路径名，

         再加上自己定义的文件夹名。

       ②用Properties类的load()方法将流加载经内存，即提取文件中的信息。

       ③关闭流：关闭的是读取流，因为流中的数据已经加载进内存。

   （3）通过getProperty()方法获取类名属性，将传入的类名赋值给指定变量。

   （4）用反射的方式，创建对象newInstance()

   （5）进行相关的具体操作。

 

 4、类加载器：

  （1）简述：类加载器是将.class的文件加载经内存，也可将普通文件中的信息加载进内存。

  （2）文件的加载问题：

     a、eclipse会将源程序中的所有.java文件加载成.class文件，以确保编译，然后放到classPath

        指定的目录中去。并且会将非.java文件原封不动的复制到.class指定的目录中去。在真正编译的

        时候，使用classPath目录中的文件，即放置.class文件的目录。

     b、写完程序是要讲配置文件放到.class文件目录中一同打包，这些都是类加载器加载的，资源文

        件（配置文件）也同样加载了配置文件。

     c、框架中的配置文件都要放到classPath指定的文件夹中，原因是它的内部就是用类加载器加载的文件。

  （3）资源文件的加载：是使用类加载器。

     a、由类加载器ClassLoader的一个对象加载经内存，即用getClassLoader()方法加载。

        若要加载普通文件，可用getResourseAsStream(String name)在classPath的文件中

        逐一查找要加载的文件。

     b、在.class身上也提供了方法来加载资源文件，其实它内部就是先调用了Loader方法，再加载的

        资源文件。

       如：Reflect.class.getResourseAsStream(String name)

 5、配置文件的路径问题：

     第一、用绝对路径，通过getRealPath()方法运算出来具体的目录，而不是内部编码出来的

       一般先得到用户自定义的总目录，在加上自己内部的路径。可以通过getRealPath()方法获取

       文件路径。对配置文件修改是需要要储存到配置文件中，那么就要得到它的绝对路径才行，因此，

       配置文件要放到程序的内部。

     第二、name的路径问题：

       ①如果配置文件和classPath目录没关系，就必须写上绝对路径，

       ②如果配置文件和classPath目录有关系，即在classPath目录中或在其子目录中（一般是

         资源文件夹resource），那么就得写相对路径，因为它自己了解自己属于哪个包，是相对于

         当前包而言的。

  示例：

    配置文件内容：

    className=java.util.ArrayList

    程序示例：

import java.io.InputStream;  
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.HashSet;  
import java.util.Properties;  
  
public class ReflectTest2 {  
    public static void main(String [] args)throws Exception{  
        //读取系统文件到读取流中  
        //方式一：  
        //InputStream ips = new FileInputStream("config.propert");  
        /*getRealPath()--得到完整的路径//如：金山词霸/内部 
         * 一定要用完整的路径，但完整的路径不是硬编码出来的，而是运算出来的。*/  
        //方式二：  
        //InputStream ips = ReflectTest2.class.getClassLoader()
 
.getResourceAsStream("cn/itcast/text1/config.propert");  
        //方式三：  
            //第一种：配置文件（资源文件）在当前包中  
        InputStream ips = ReflectTest2.class
 
.getResourceAsStream("resourse/config.propert");  
            //第二种：配置文件（资源文件）不在当前包中，和此包没太大关系  
        //InputStream ips = ReflectTest2.class.getClassLoader()
 
.getResourceAsStream("cn/itcast/test2/resourse/config.properties");  
          
        //加载文件中的键值对  
        Properties props = new Properties();  
        props.load(ips);  
        //关闭资源，即ips调用的那个系统资源  
        //注意：关闭的是ips操作的流，加载进内存后，就不再需要流资源了，需要关闭  
        ips.close();  
        //定义变量，将文件中的类名赋值给变量  
        String className = props.getProperty("className");  
        //通过变量，创建给定类的对象  
        Collection cons =   
                (Collection)Class.forName(className).newInstance();  
          
        //将元素添加到集合中  
        /*Collection cons = new HashSet();*/  
        ReflectPoint pt1 = new ReflectPoint(3,3);  
        ReflectPoint pt2 = new ReflectPoint(5,5);  
        ReflectPoint pt3 = new ReflectPoint(3,3);  
        cons.add(pt1);  
        cons.add(pt2);  
        cons.add(pt3);  
        cons.add(pt1);  
        //移除元素  
        cons.remove(pt1);  
        System.out.println(cons.size());  
    }  
}  
 
 
 

 

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