Java中的反射--Reflect

　　在张孝祥老师的Java讲解中，学习到了Java反射的一部分知识，觉得有必要好好学习一下哈。

一、反射的理解

经典总结：反射就是把Java类中的各种成分映射成为相应的Java类

例如：一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量、方法、构造方法、包等信息也用一个个的Java类来表示，表示Java类中的Class类显然要提供一系类的方法，来获得其中的变量、方法、构造方法、修饰类、包等信息，这些信息就是用相应的实例对象来表示，它们是Field、Method、Contructor、Package等

反射的缺点：反射导致程序性能下降

二、构造方法（Constructor）反射

理解：就是获取到某一个Class类中的所有的构造方法Constructor类

 // 获得某个类的所有的构造方法
 Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
 
 // new String(new StringBuffer("abc"))
 // 得到String类的某一个构造方法
 Constructor constructor = String.class.getConstructor(StringBuffer.class);
 String str2 = (String) constructor.newInstance(new StringBuffer("abc"));

三、成员变量（Field）反射

理解：获取一个Class类中的成员变量的Field，以及通过反射获取其中某一个对象的成员变量的值

 public class ReflectPoint {
 
     private int x;
     public int y;
 
     public ReflectPoint(int x, int y) {
         super();
         this.x = x;
         this.y = y;
     }
 }
 
 ReflectPoint rf1 = new ReflectPoint(3, 5);
 // 获取Class类的Field成员变量，并没有指定是哪个对象的 fieldY不是对象上的变量，而是Class类上的变量，要用他去取某个对象上的值
 Field fieldY = rf1.getClass().getField("y");
 // 获取rf1这个对象的成员变量的值
 Object obj = fieldY.get(rf1);
 System.out.println(obj);
 
 // 获取Class类的Field成员变量，并没有指定是哪个对象的 这里x是私有的属性，但是也可以通过反射暴力获得
 Field fieldX = rf1.getClass().getDeclaredField("x");
 // 暴力反射
 fieldX.setAccessible(true);
 // 获取rf1这个对象的成员变量的值
 Object objX = fieldX.get(rf1);
 System.out.println(objX);

注意：其中的注解也写的比较清楚，但是还想强调一下，Field类只是获取到了字节码中的成员变量，但是并没有获取到某一个特定对象的成员变量的具体的值

成员变量反射的综合案例：

题目：将任意一个对象中所有的String类型的成员变量所对应的字符串中的“b”转化成“a”，这其中用到了成员变量的反射，具体代码如下所示

 public class ReflectPoint {
 
     private int x;
     public int y;
     public String str1 = "ball";
     public String str2 = "basketball";
     public String str3 = "itcast";
 
     public ReflectPoint(int x, int y) {
         super();
         this.x = x;
         this.y = y;
     }
 }
 
     private static void changeStringValue(Object obj) throws Exception {
         Field[] fields = obj.getClass().getFields();
         for(Field field: fields){
             //if(field.getType().equals(String.class)){
             //这里就直接用 == 比较在内存中编译的字节码文件
             if(field.getType() == String.class){
                 String oldValue = (String) field.get(obj);
                 String newValue = oldValue.replace('b', 'a');
                 field.set(obj, newValue);
             }
         }
     }

总结：其实这种反射的应用在spring框架的源码中应该是挺常见的，有时间去看看spring的源码，我想真正懂了反射的原理之后，再去读spring的源码的话，会轻松很多的！

四、成员方法（Method）类

理解：可以获取一个类中的成员方法

 String str1 = "abc";        
 
 Method methodCharAt = String.class.getMethod("charAt", int.class);
 // 注意这个invoke方法，这个是调用的意思，就是这个方法调用执行，传入new出来的对象以及参数
  System.out.println(methodCharAt.invoke(str1, 1));
 // 如果是静态方法的话，是不用传入new 出来的对象的，只需要传入参数即可
 // System.out.println(methodCharAt.invoke(null, 1));

注意：静态方法，直接传入null即可，因为静态方法都是放在方法区中的，对象在栈中创建出来，就可以直接调用

高能：用反射方式执行某个类中的main方法（写个程序，根据用户提供的类名，去执行该类中的main方法）

为什么我很费劲的去用反射区调用main方法呢，这里其实可以引出一个前提条件，就是我并不知道到底是哪个类的main方法，但是类名可能就存在传递的参数中，我通过得到参数，得到类名，然后通过反射，启动main方法？？？

     static class TestArguments{
         public static void main(String[] args) {
             for(String arg:args){
                 System.out.println(arg);
             }
         }
     }
 
       //TestArguments.main(new String[]{"111","222","333"});
       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"}});

五、数组（Array）反射

直接上代码吧，数组的反射应该在开发框架中会得到使用，直接看一下简单的代码吧，当然那个Array是java中的reflect包中的类：java.lang.reflect.Array

     private static void printObject(Object obj1) {
         Class clazz = obj1.getClass();
 
         if(clazz.isArray()){
             int len = Array.getLength(obj1);
             for(int i=0;i<len;i++){
                 System.out.println(Array.get(obj1, i));
             }
         }else{
             System.out.println(obj1);
         }
     }
 
         printObject(obj1);
         printObject(new int[]{1,2,3});