Java 反射机制

Java的反射机制是怎样的？
当一个字节码文件加载到内存的时候，JVM会对该字节码进行解剖，然后会创建一个对象的class对象，把字节码文件的信息全部都存储到该class对象中，我们只要获取到class对象，就可以使用字节码对象设置对象的属性或者调用对象的方法等

注意：在反射技术中一个类的任何成员都有对应的类进行描述。比如成员变量（Filed）方法—->Method等

获取class对象的三种方式
要获取的class对象：

package d0321;
public class Exercise {
    int ci = 3;
    private int ei = 4;
    public Exercise(){
        System.out.println("这是无参的构造函数！");
    }
    Exercise(int i){
        System.out.println("这是一个参数的构造函数！");
    }


    public void run1(){     
        System.out.println("这是无参的一般方法run1()");      
    }

    public static void run2(){
        System.out.println("这是无参的静态方法run2()");      
    }
    private void run3(){
        System.out.println("这是私有的无参的一般方法run3()");       
    }
}

---

获取class对象的方式一、

package d0321;
//通过Class.forName("包名+.+类名");
public class ReflectTest {
    public static void main(String[] args) {
        try {
            Class cla = Class.forName("d0321.Exercise");
            System.out.println(cla);
        } catch (ClassNotFoundException e) {

            e.printStackTrace();
        }   
    }
}

输出：

class d0321.Exercise

获取class对象的方式二、

package d0321;
//通过类名.class
public class ReflectTest {
    public static void main(String[] args) {
            Class cla = Exercise.class;
            System.out.println(cla);    
    }
}

输出：

class d0321.Exercise

获取class对象的方式三、

package d0321;
//通过对象获取
public class ReflectTest {
    public static void main(String[] args) {        
        Class cla =(new Exercise()).getClass();
        System.out.println(cla);        
    }
}

输出：

这是无参的构造函数！
class d0321.Exercise

当我们有了class对象后：

package d0321;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//通过对象获取
public class ReflectTest {
    public static void main(String[] args) throws Exception{        
        //获取对应的class对象
        Class cla = Class.forName("d0321.Exercise");
        //通过class对象获取对应的构造方法
        Constructor[] con1 = cla.getConstructors();//不能获取默认的（空修饰）、私有的
        for (Constructor constructor : con1) {
            System.out.println(constructor);
        }

        Constructor[] con2 = cla.getDeclaredConstructors();//所有的构造方法
        for (Constructor constructor : con2) {
            System.out.println(constructor);
        }

        Constructor con3 = cla.getConstructor(int.class);//获取单个指定的构造方法(共有的)     
        Exercise ex1 =  (Exercise) con3.newInstance(20);//.newInstance()创建一个Object类型对象

        Constructor con4 = cla.getDeclaredConstructor(null);//获取单个指定的构造方法(所有的)      
        con4.setAccessible(true);//设置访问权限（使私有权限失效）
        Exercise ex2 =  (Exercise) con4.newInstance();
        ex2.run2();//静态方法

        //反射使用Method类描述方法
        //获取所有公共的方法(包括父类)
        Method[] mes = cla.getMethods();
        for (Method method : mes) {
            System.out.println(method);
        }
        //获取所有的方法(不包括父类)
        Method[] mes1 = cla.getDeclaredMethods();
        for (Method method : mes1) {
            System.out.println(method);
        }
        Method mes2 = cla.getMethod("run1",null);//获取特定公共方法
        mes2.invoke((new Exercise(1)), null);//启动方法。第一个参数：方法的对应的对象。第二个参数：传入的参数

        Method mes3 = cla.getDeclaredMethod("run3",null);//获取特定公共方法
        mes3.setAccessible(true);//设置访问权限（使私有权限失效
        mes3.invoke((new Exercise(1)), null);//第一个参数：方法的对应的对象。第二个参数：传入的参数

        Method mes4 = cla.getDeclaredMethod("run2",null);//获取特定公共方法
        mes4.invoke(null, null);//第一个参数：静态方法，直接null。第二个参数：传入的参数

        //反射使用Field类描述了成员变量

        Field[] f1 = cla.getFields();//公共的成员变量
        for (Field field : f1) {
            System.out.println(field);
        }

        Field[] f2 = cla.getDeclaredFields();//所有的成员变量
        for (Field field : f2) {
            System.out.println(field);
        }   

        Exercise exer = new Exercise(0);
        Field f3 = cla.getField("ci");
        f3.setAccessible(true);//设置访问权限（使私有权限失效)
        f3.set(exer, 6);//第一个参数：设置该数据的成员变量。第二个参数：传入的属性值
        System.out.println(exer.ci);        
    }
}