java高新技术-反射

一、反射的基石->Class类

　　定义一个类使用 class

　　有一个类叫Class

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

　　Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，Class类代表Java类，

　　它的各个实例对象又分别对应什么呢？

　　　　->对应各个类在内存中的字节码，例如，Person的字节码，ArrayList类的字节码...

　　　　->一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的

　　　　　　所以他们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象类表示，这些对象显然具有相同的类型

1.类的字节码

　　Class cls1 = 字节码1;

　　Class cls2 = 字节码2;

　　Class的实例对象代表内存里的一份字节码；

　　什么叫字节码？

　　　　Person p1 = new Person();

　　　　当我们在源程序中用到了Person这个类的时候，会把编译好的二进制代码(.class)加载到内存中，接着才能用它创建一个个的对象。

　　　　加入用到了 Person Date Math 三个类，就会在内存中存在3份字节码，即每一份字节码都是一个Class类的实例对象。

　　　　Class cls1 = Date.class

　　　　Class cls2 = Person.class

获取字节码的方式有3种：

　　① 类名.class 例如：  Date.class;  //使用Date.class获取类的字节码(类.class)

　　② 对象.getClass() 例如：Person p1 = new Person();

　　　　　　　　　　　　　　　p1.getClass();  //获取类的字节码

　　③ Class.forName("类名")，例如：Class.forName("java.lang.String") //获取类的字节码

　　面试题：Class.forName()的作用

　　使用Class.forName() 返回类的字节码，获取时有两种情况：

　　　　①.类的字节码已经被加载过，在java虚拟机中，不需要加载可以直接返回

　　　　②.JVM中还没有字节码，用类加载器加载，把加载进来的字节码缓存到JVM中，以后要得到字节码就不用再加载了

每一个字节码都是一个Class的实例对象

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

   8个基本类型（byte, short, boolean ,char, int, long, float,double）

　和void

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

　　Class.isArray()

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

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");
        //3种方式都是同一份字节码
        System.out.println(cls1 == cls2);
        System.out.println(cls1 == cls3);
 
        //isPrimitive 是否是基本类型
        System.out.println(cls1.isPrimitive()); //flase
        System.out.println(int.class.isPrimitive()); //true
        System.out.println(int.class == Integer.class); //false
        //Integer.TYPE 代表包装类的基本类型的字节码
        System.out.println(int.class == Integer.TYPE); //true
        System.out.println(int[].class.isPrimitive()); // flase
        System.out.println(int[].class.isArray());  //true
    }

二、反射

　　反射就是把Java类中的各种成分映射成相应的java类（Field,Method,Contructor,Package...）。

　　Method 的对象就是一个具体的方法

　　我们通过写程序可以得到这个类里面的各个成分所对应的类的对象

1.构造方法的反射应用

一个Class代表一个字节码，一个Method代表这个字节码里的一个方法，一个Contructor就代表一份自己码里的构造方法

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

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

获取指定构造方法，并调用构造方法：

//new String(new StringBuffer("abc"))
        Constructor constructor = String.class.getConstructor(StringBuffer.class);
        String str2 = (String)constructor.newInstance(new StringBuffer("abc"));
        System.out.println(str2.charAt(2));

如果改成：

//new String(new StringBuffer("abc"))
        Constructor constructor = String.class.getConstructor(StringBuffer.class);//获取构造方法时需要类型
        String str2 = (String)constructor.newInstance("abc");  //调用构造方法时需要传递同样类型的对象
        System.out.println(str2.charAt(2));

会报如下错误：

Exception in thread "main" java.lang.IllegalArgumentException: argument type mismatch
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:526)
    at com.java.enhance.ReflectTest.main(ReflectTest.java:23)

表示类型不匹配，获取构造方法时传的是StringBuffer.class

Class.newInstance()方法：

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

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

　　该方法内部的具体代码是怎样写的呢？ 用到了缓存机制来保存默认的构造方法的实例对象。

2.成员变量的反射

ReflectPoint.java

public class ReflectPoint {
 
    private int x;
    public int y;
 
    public ReflectPoint(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
 
}

ReflectTest.java

ReflectPoint pt1 = new ReflectPoint(3, 5);
        Field fieldY = pt1.getClass().getField("y");
        //fieldY不是对象身上的变量，而是类上，要用它去取某个对象对应的值
        System.out.println(fieldY.get(pt1));
 
        //由于x是private修饰，会报错 java.lang.NoSuchFieldException: x，
//        Field fieldX = pt1.getClass().getField("x");
//        System.out.println(fieldX.get(pt1));  
 
        //获取私有变量  暴力反射
        Field fieldX = pt1.getClass().getDeclaredField("x");
        fieldX.setAccessible(true);
        System.out.println(fieldX.get(pt1));  

3.成员变量反射的综合案例

public class ReflectPoint {
 
    private int x;
    public int y;
    public String z = "basketball";
    public String z1 = "abc";
 
    public ReflectPoint(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
 
    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "ReflectPoint [x=" + x + ", y=" + y + ", z=" + z + ", z1=" + z1
                + "]";
    }
 
}

将对象中的String类型的成员变量所有的字符b换为字符a

    public static void main(String[] args){  
　　　　  exchangeCharValue(pt1);
         System.out.println(pt1);
    }
 
    //将对象中的String类型的成员变量所有的字符b换为字符a
    private static void exchangeCharValue(Object obj) throws Exception {
        Field[] fields = obj.getClass().getFields();
        for(Field field : fields){
//            if(field.getType().equals(String.class)){
            if(field.getType() == String.class){ //这里用 == 比equals更准确，字节码只有一份自己和自己比较
                String oldValue = (String)field.get(obj);
                String newValue = oldValue.replace('b', 'a');
                field.set(obj, newValue);
            }
        }
    }

4.成员方法的反射

String str1 = "abc";
Method chartAtMethod = Class.forName("java.lang.String").getMethod("charAt", int.class);
//通常方式
System.out.println(str1.charAt(1));//b
//反射方式
System.out.println(chartAtMethod.invoke(str1, 1));
System.out.println(methodCharAt.invoke(str1, new Object[]{2})); //c

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是没有可变参数

如果传递给Method对象的invoke()方法的第一个参数为null,这有着什么意义呢？

说明该Method对象对应的是一个静态方法！

5.对接受数组参数的成员方法进行反射

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

　　　　　用普通法师调用完后，要明白为什么要用反射方式去调用？

public static void main(String[] args) throws Exception{
        String startingClassName = args[0];
        Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
        mainMethod.invoke(null, (Object)new String[]{"111","222","333"});
　　　　 mainMethod.invoke(null, new Object[]{new String[] { "111", "222", "333" }});
    }

 添加参数

 问题：　　

　　启动Java程序的main方法的参数是一个字符串数组，及public static void main(String[] args),

　　通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，

　　而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会

　　到底按照那种语法进行处理？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.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中传了一个数组作为实参，对呗拆包成为多个参数。

所以，在给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"});

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

6.数组的反射

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()); //true
        System.out.println(a1.getClass().getName()); //[I
        System.out.println(a1.getClass().getSuperclass().getName());//java.lang.Object
        System.out.println(a4.getClass().getSuperclass().getName());//java.lang.Object
 
        System.out.println(Arrays.asList(a1));//[[I@206c2ea3]
        System.out.println(Arrays.asList(a4)); //[a, b, c]
 
        Object aObj1 = a1;
        Object aObj2 = a4;
        Object[] aObj4 = a3;
        Object[] aObj5 = a4;

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

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

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

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

　　　　Arrays.asList(new String[]{"a","b","c"})  => [a,b,c]

　　　　Arrays.asList(new int[]{1,2,3})  =>[I@xxxxxxx(哈希Code码)

　　　　处理String[] 时使用的是jdk1.4的语法(当作Object[]，1.4没有可变参数的概念，使用的是Object[]当作参数)，处理int[] 时用的jdk1.5的语法(当作Object一个参数来处理，有可变参数的概念，使用的是Object...args)

7.数组反射的应用

private void printObject(Object obj){
  Class clazz = obj.getClass();
  if(class.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);
   }
}    

思考：

　　怎么得到数组中的元素类型？

　　　　没有办法得到数组中元素类型。

　　　　int[] a = new int[3];

　　　　Object[] a = new Object[]{"a",1}

　　　　只能得到某一个元素的类型 a[0].getClass().getName();

8. ArrayList_HashSet的比较及Hashcode分析

　　hashCode()方法的作用

　　

　　 

public static void main(String[] args) {
        Collection collection = new HashSet<>();
        ReflectPoint pt1 = new ReflectPoint(3, 3);
        ReflectPoint pt2 = new ReflectPoint(5, 5);
        ReflectPoint pt3 = new ReflectPoint(3, 3);
        collection.add(pt1);
        collection.add(pt2);
        collection.add(pt3);
        collection.add(pt1);
//        pt1.y = 7;  //修改后hashCode值就不同了，导致找不到这个对象了，也无法删除
        collection.remove(pt1);
        /**
　　　　　　1.如果实体类只重写了equals(),没有重写hashCode() 则collection总的个数为3
　　　　　　 因为，在存储一个对象进HashSet中时，如果没有重写hashCode方法，导致两个对象计算出来的hashCode值是不相同的（hashCode值是根据对象在内存中的地址计算出来的）
　　　　　　 我在我的区域里边找，不在那个已经存储同样对象的区域里边找，所以这个对象还是会被存储进去
　　　　　　为了让相等的对象找到在相同的区域，就有一个说法，如果两个对象的equals相等时，应该让他们的hashCode也应该相等
　　　　　　如果对象没有要存到hash集合里边，就没必要重写hashCode();
         * 如果要放入HashSet中的对象没有重写hashCode方法和equals方法，
         * 两个对象的引用不同，还是会存入HashSet中，默认的equals方法使用 == 比较两个对象的内存地址值
         * 如果重写hashCode与equals方法，会认为是相同的对象，后边要存入的存入不了
         *
         * 当一个对象被存进HashSet集合中后，就不能修改这个对象中参与计算哈希值的字段了，否则，对象
         * 修改后的哈希值与最初存进HashSet集合中的哈希值就不同了，在这种情况下，即使在
         * contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回
         * 不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄漏。
         */
        System.out.println(collection.size()); 
        /**
         * 通常来说，一个类的两个实例对象用equals()方法比较的结果相等时，他们的哈希吗也必须相等，但
         * 反之则不成立，及equals方法比较结果不相等的对象可以有相同的哈希码，或者说哈希吗相同的两个对象，
         * equals方法比较的结果可以不相同，例如 字符串"BB"和"Aa"的equals比较结果不相同，但hashCode()结果相等。
         */
        System.out.println("BB".hashCode());  //
        System.out.println("Aa".hashCode());
    }

内存泄漏的问题也可以用此例子举例，

所谓内存泄漏，就是这个对象不再使用了可一直占用内存空间，无法释放掉。

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

　　例如：要调用某个类的main方法，但是不知道要调用哪个类，这个类是动态传过来的，就类似一个小的框架。

　　你调用别人写的类，与别人调用你写的类，一个叫工具，一个叫框架（框架调用你的类）

　　框架与框架要解决的核心问题

　　　　-> 我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

　　框架要解决的核心问题

　　　　-> 因为在写程序时无法知道要调用的类名，所以，在程序中无法直接 new 某个类的实例对象了，而要用反射（Class.forName()）的方式类做。

public static void main(String[] args) throws Exception{
        InputStream is = new FileInputStream("config.properties");  //尽量面向父类或面向接口编程
        /**
         * Perperties类似于HashMap，比HashMap多了点功能，可以把内存中的键值对存到硬盘的文件中去,
         * 也可以在初始化时把硬盘中的键值对文件加载到内存中
         */
        Properties props = new Properties();
        props.load(is);
        /*
         * 马上关闭资源，否则会有一点小小的内存泄漏
         * 这个内存泄漏不是对象没有被释放，而是对象关联的系统资源没被释放
         */
        /*
         * 告诉系统把关联的系统资源干掉，本对象有可能还在，后续由垃圾回收释放掉
         * 自己在垃圾回收之前，先把自己关联的系统资源释放掉
         */
        is.close();
        String className = props.getProperty("className");
        Collection collection = (Collection)Class.forName(className).newInstance();
}

config.properties

　　className=java.util.ArrayList

10.用类加载器的方式管理资源和配置文件

　　上述代码中的 InputStream ips = new FileInputStream("config.properties");在项目开中不会这么搞，一般要用完整的路径，但完整的路径不是硬编码，而是运算出来的。

　　.class 需要被类加载器加载到内存中，类加载器会提供一个方法加载普通文件。

　　InputStream is = ReflectTest2.class.getClassLoader().getResourceAsStream("config.properties");

　　使用getClassLoader()这种方式时，需要把配置文件放在classpath目录下，因为getClassLoader加载.class文件就是在classpath目录下加载，所以当然加载配置文件时也需放到classpath目录下

　　getResourceAsStream(),是在在classpath指定的目录下逐一查找需要加载的文件。

　　此时config.properties文件需放在src目录下，如果放在包下，需要写上目录名getResourceAsStream("com/java/config.properties")，在使用eclipse时会自动将配置文件复制到classpath目录下，真正在运行时用的是classpath目录下

也可以使用：

　　InputStream is = ReflectTest2.class.getResourceAsStream("config.properties"); //表示与当前类所在目录的相对路径下，即应该与当前类在同一个目录，用自己的类加载的时候可以用相对也可以用绝对，其内部还是使用的getClassLoader(),大部分框架内部都是使用类加载器加载配置文件，如果使用Eclipse开发，放在src目录下会自动拷贝的classpath目录下。