[黑马程序员]（第31天）高新技术之反射

来源：互联网发布：js实现圆圈动态显示编辑：程序博客网时间：2024/06/09 14:10

------- 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类使用反射获取其成员变量的示例。

[java] view plaincopy
 /*创建一个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'。

[java] view plaincopy
/** 
  * 将传入的参数字符串中的字符'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方法的代码演示

[java] view plaincopy
 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工具类用于完成对数组的反射操作

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

[java] view plaincopy
/** 
  
  * 通过判断传入的对象将其打印，如果是数组，逐个打印其元素；若不是数组，直接打印。 
  
  * @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

程序示例：

[java] view plaincopy
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());    
    }    
}    
   
   
   

0 0