黑马程序员_Java基础：反射机制（Reflection）总结

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

反射在java中有非常重大的意义，它是一种动态的相关机制，可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods具体定义），并生成其对象实体、或对其fields设值、或使用其methods。反射是框架的基础，而框架能大大节省java程序的开发成本，是日后工作中经常会碰到的技术。所以，学习好反射的重要性就不言而喻了。

一、概念

java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。反射的动态特性极大地体现了java的灵活性。

很多人刚接触反射的时候，可能觉得不大好理解，那是因为对反射的过程了解得不够清楚。我们要知道，反射都是通过传递class来间接完成目的。

比如想通过反射调用一个类的构造方法来创建对象，那么就要先得到那个类的字节码对象（class）。而类的字节码对象是属于Class类，Class类有提供获取class对象中包括构造方法，成员方法，以及字段所属类（Constructor，Methods，Field）的方法。那么我们只要使用字节码对象调用Class中的getConstructor()方法，即可获取对象中的构造方法的所属类，最后通过构造方法的所属类获取构造方法。当我们最终获取构造方法后，就能成功创建对象。

如果文字表达的不够清楚，可以看以下图解：

二、反射机制的优点与缺点

首先要弄清楚为什么要用反射，这涉及到了动态与静态的概念。

　　静态编译：在编译时确定类型，绑定对象,即通过。
　　动态编译：运行时确定类型，绑定对象。

反射的优点就是：它的动态创建对象和编译，最大限度发挥了java的灵活性，体现了多态的应用，又可以降低类之间的藕合性。
      它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM虚拟机，我们希望做什么并且它满足我们的要求，但这类操作总是慢于只直接执行相同的操作。

三、使用方法

首先需要了解一下，java.lang.reflect包中的一些类来的含义。
      常用的类有：
      Class：包含某个类的全部信息，包括属性、方法、构造方法等。（java.lang包）
      Construtor：代表类中的构造方法。
      Method：代表类中的方法。
      Field：代表类中的属性。

步骤（结合图解）：
      （1）取得对象的class字节码对象。
      根据字符串全类名：Class cls=Class.forName(String className)；
      根据对象：Class cls=obj.getClass(); //获取当前对象所属的类
      根据类：Class cls=Person.class;　

（2）取得对象成员所属的类
      取得所有字段的所属类的数组：Field[] field=cls.getDeclaredFields();
      取得所有公共字段的所属类的数组：Field[] field=cls.getFields();
      取得指定的字段的所属类：Field fields=cls.getDeclaredField (String name);
      取得指定的公共字段的所属类：Field fields=cls.getField (String name);

取得所有方法的所属类的数组：Method[] methods=cls.getDeclaredMethods()；
      取得指定方法的所属类：Method method = cls.getJMethod();

取得所有构造方法的所属类的数组：Constructor[] con = cls.getConstructors();
      取得指定构造方法的所属类：Constructor con = cls.getConstructor(Class... parameterTypes) ;

（3）使用对象成员所属类获取对象成员
      获取指定字段：Object objField = field.get();

获取指定方法：Object objMethod = method.invoke(Object obj, Object... args) ;

获取指定构造方法：Object objCon = con.newInstance(Object... initargs) ;

四、应用

1.例子一（通过反射获取类的构造方法）：（以下例子为了方便阅读，异常都做抛处理）

 import java.lang.reflect.Constructor;

 public class ReflectTest {

     public static void main(String[] args) throws Exception {
 //        通过反射获取一个类的构造方法。注意反射比较消耗资源，会影响程序性能。
         Constructor<String> cons = String.class.getConstructor(StringBuffer.class);
 //        也可通过获取到的构造方法反过来获取构造方法所属的类。
         Class<String> cls4 = cons.getDeclaringClass();
         System.out.println(cls4);
     }
 }

运行结果为：

class java.lang.String

2.例子二（通过反射获取类中字段、改变字段的值）：

 public class Student {
     private int high;
     public int wight;
     public String str1 = "ball";
     public String str2 = "basketball";
     public String str3 = "hello";

     public ReflectPiont(int high, int wight) {
         super();
         this.high = high;
         this.wight = wight;
     }
 }

 import java.lang.reflect.Field;

 import com.gzjzone.jul262015.ReflectPiont;

 public class ReflectTest {

     public static void main(String[] args) throws Exception {
         Student s1 = new Student(3, 5);
 //        getField方法返回的不是具体的变量y，而是一个类，通过这个类调用get方法才能获取具体对象上变量。
         Field fieldW = s1.getClass().getField("wight");
         System.out.println(fieldW.get(s1));

 //        因为s1上的x变量是私有的,所以要用getDeclaredField,只要是声明的变量都能提取成类。
         Field fieldH = s1.getClass().getDeclaredField("high");
 //        同理s1上的x变量是私有的，所以只能通过暴力反射的方法获取x。
         fieldH.setAccessible(true);
         System.out.println(fieldH.get(s1));

         changeStringValue(s1);
         System.out.println(s1);
     }

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

运行结果：

5
3
aall:aasketaall:hello

3.例子三（通过反射，获取类中的方法）：

import java.lang.reflect.Method;

public class ReflectTest {

    public static void main(String[] args) throws Exception {
//        使用反射调用main方法。
//        先假设本类运行时会接收到TestArguments的名称。
        String className = args[0];
        Method mainMethod = Class.forName(className).getMethod("main", String[].class);
//        在jdk1.4中invoke方法的参数列表是(Object,Object[])，invoke方法接收到Object[]后会拆开。
//        而jdk1.5以后invoke方法的参数列表是可变参数列表(Object,...arg)。
//        因为1.5是兼容1.4的，所以如果把String[]传进invoke方法，会被拆开，这不符合要求。
//        解决方法为：1.把String[]作为一个元素装进一个Object[]中；2.把String[]强制转成Object。
//        如果invoke方法第一个参数为null，表示调用的是静态方法。
        mainMethod.invoke(null, (Object)new String[]{"111","222","333"});
    }
}

class TestArguments{
    public static void main(String[] args){
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

运行结果：

111
222
333

4.例子四（通过反射，获取数据元素）：

import java.lang.reflect.Array;

public class ReflectTest {

    public static void main(String[] args) throws Exception {
//        通过反射获取数组，Array。
        int[] arr = {1,2,3};
        printObject(arr);
        printObject("xyz");
    }

    private static void printObject(Object obj) {
        if (obj.getClass().isArray()) {
            int len = Array.getLength(obj);
            for (int x = 0; x < len; x++) {
                System.out.println(Array.get(obj, x));
            }
        }
        else{
            System.out.println(obj);
        }
    }
}

运行结果为：

1
2
3
xyz

5.例子五（基础框架）：

 public class Student {
     private int high;
     public int wight;

     public ReflectPiont(int high, int wight) {
         super();
         this.high = high;
         this.wight = wight;
     }

     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + x;
         result = prime * result + y;
         return result;
     }

     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         ReflectPiont other = (ReflectPiont) obj;
         if (x != other.x)
             return false;
         if (y != other.y)
             return false;
         return true;
     }

     @Override
     public String toString(){
         return str1+":"+str2+":"+str3;
     }
 }

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;

public class ReflectTest {
    public static void main(String[] args) throws Exception {

//        运用框架的方式创建对象，好处就是可以先做框架，后再创建对象对应类，从而增强程序的适用性。
//        框架完成后，创建对象是，只要先通过配置文件的方式获取对象对应的类名即可。
        InputStream ips = new FileInputStream("config.properties");    //内容为className=java.util.HashSet
        Properties pro = new Properties();
        pro.load(ips);
        ips.close();
        String className = pro.getProperty("className");
        //Class类中本身也有newInstance()方法，它实际是调用Constructor类中的newInstance(),只能获取类的空参数构造函数。
        Collection col = (Collection)Class.forName(className).newInstance();

        Student s1 = new Student(2, 4);
        Student s2 = new Student(3, 6);
        Student s3 = new Student(2, 4);

        col.add(s1);
        col.add(s1);
        col.add(s2);
        col.add(s3);

/*        注意，在hashSet集合中，因为y的值有参与hashCode值的运算，所以修改y后，
        pt1指向的对象内存hashCode地址已变，而pt1指向的还是原来对象的地址。
        最后删除的是pt1指向的原对象地址，而变更后的对象地址则还存在，造成内存溢出。*/
        pt1.y = 6;
        col.remove(pt1);

        System.out.println(col.size());
    }
}

运行结果为：

2

以上就是本人现阶段所学习到的反射知识总结，若以后对反射有更加深的见解或建议，再继续完善文章。