Java 学习之反射机制“解刨”分解类，并获取内容！

正常情况下，单纯的做开发是接触不到反射机制的（额，当然并不排除例外的情况了）。下面我就对我学到的反射方面的知识做一个小小的总结，旨在复习和以后的查看。

---

原理分析：

所谓反射就是将一个类当做我们研究的对象，进行分解，获取其中的内容的过程。其核心就是Class类，他是所有类的研究的对象，基于Class我们就可以获取一个类的字节码，进而获取想要的值。

目标类（待解刨的类）

---

---

package reflect;

public class Person {

    public Person(){}

    private String name;
    public int address;

    public int getAddress() {
        return address;
    }

    public void setAddress(int address) {
        this.address = address;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name ){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    private Person(int name){
        System.out.println("这里是私有的带有参数的构造方法！");
    }

    public void eat(){
        System.out.println("吃饭！");
    }

    public void drink(String name){
        System.out.println("正在喝 ："+ name);
    }

    public void purchase(String address ,int [] number , String [] item){
        System.out.println("这个人在  " + address +"  买了 "+item +"  分别  "+ number+" 个！");
    }

    private String flay(String tool){
        return "I Can Flay By "+ tool;
    }

    public static String spend(String money){
        System.out.println("我只能够花费 "+money +"钱！");
        return "你造吗？";
    }

    public static void main(String[] args) {
        System.out.println(args[0]);
    }

}

---

反射构造方法小例子

---

package reflect;

import java.lang.reflect.Constructor;

import org.junit.Test;

public class ReflectConstructor {

    /**
     * 反射得到无参的构造函数的方法
     * @throws Exception
     */
    @Test
    public void reflect1() throws Exception{
        Class cls = Class.forName("reflect.Person");
        Constructor c = cls.getConstructor(null);
        Person person = (Person) c.newInstance(null);
        System.out.println("反射得到的结果是："+ person.toString());
    }

    /**
     * 反射出带有参数的构造方法
     * @throws Exception
     */
    @Test
    public void reflect2() throws Exception {
        Class cls = Class.forName("reflect.Person");
        Constructor c = cls.getConstructor(String.class);
        Person person = (Person) c.newInstance("Name");
        System.out.println("反射获得的有参的结果是："+ person.getName());
    }

    /**
     * 反射出私有的带有参数的构造方法
     * @throws NoSuchMethodException
     * @throws Exception
     */
    @Test
    public void reflect3() throws NoSuchMethodException, Exception {
        Class cls = Class.forName("reflect.Person");
        Constructor c = cls.getDeclaredConstructor(int.class);
        //java语言默认私有的方法是不能被外界访问的到的，但要进行强制的访问需要加上一层权限
        c.setAccessible(true);
        Person person = (Person) c.newInstance(201492115);

        System.out.println("反射出私有的带有参数的构造方法！"+ person.toString());
    }

}

---

反射所有方法的小例子

---

package reflect;

import java.lang.reflect.Method;

import org.junit.Test;

public class ReflectMethods {

    /**
     * 反射测试一个无参的方法
     * public void eat()
     * @throws Exception
     */
    @Test
    public void feflect1() throws Exception {
        Class cls = Class.forName("reflect.Person");
        Method method =cls.getMethod("eat", null);
        System.out.println(method.toString());
        method.invoke(new Person(), null);
        method.invoke(cls.newInstance(), null);
    }

    /**
     * 反射测试一个带有参数的方法
     * public void drink(String name)
     * @throws Exception
     */
    @Test
    public void reflect2() throws  Exception {

        Class cls = Class.forName("reflect.Person");
        Method method =cls.getMethod("drink", String.class);
        System.out.println(method.toString());
        method.invoke(new Person(), "中国凉茶");
        method.invoke(cls.newInstance(), "中国凉茶");
    }

    /**
     * 反射测试含有多个复杂类型的参数的方法
     * public void purchase(String address ,int [] number , String [] item)
     * @throws Exception
     */
    @Test
    public void reflect3() throws Exception {
        Class cls = Class.forName("reflect.Person");
        Method method = cls.getMethod("purchase", String.class,int[].class,String[].class);
        method.invoke(cls.newInstance(), "大连",new int[]{1,2,3},new String[]{"鱿鱼","贝壳","螃蟹"});
    }

    /**
     * 反射测试一个带有返回值的不含参数的方法
     * public String getName()
     * @throws Exception
     */
    @Test
    public void reflect4() throws Exception {
        Class cls = Class.forName("reflect.Person");
        Method method = cls.getMethod("getName", null);
        String result = (String) method.invoke(cls.newInstance(), null);
        System.out.println("测试带有返回值的无参的方法，所得的结果是： "+result);

    }

    /**
     * 反射测试私有含参数的方法
     * private String flay(String tool)
     */
    @Test
    public void reflect5() throws Exception {

        Class cls = Class.forName("reflect.Person");
        //对于私有的方法只能通过getDeclaredMethod方式得到
        Method method = cls.getDeclaredMethod("flay", String.class);
        //记得强制将访问人权限提升起来到"可以访问的到"
        method.setAccessible(true);
        String result = (String) method.invoke(cls.newInstance(), "蝙蝠侠的风衣！");
        System.out.println("反射测试私有的含参数的方法的结果是： "+ result);
    }

    /**
     * 反射测试私有的含参数的静态的方法
     * public static String spend(String money)
     */
    @Test
    public void reflect6() throws Exception {

        Class cls = Class.forName("reflect.Person");
        //对于静态的方法只能通过getDeclaredMethod方式得到
        Method method = cls.getDeclaredMethod("spend", String.class);

        String result = (String) method.invoke(cls.newInstance(), "100000000000000元人民币！");
        System.out.println("反射测试私有的含参数的方法的结果是： "+ result);
    }

    /**
     * 反射测试主方法
     * public static void main(String[] args)
     * @throws Exception
     */
    @Test
    public void reflect7() throws Exception {
        Class cls = Class.forName("reflect.Person");
        Method method = cls.getMethod("main",String[].class);
        method.invoke(null, (Object)new String[]{"A","B","C"});
    }

}

---

反射字段值的小例子

---

package reflect;

import java.lang.reflect.Field;

import org.junit.Test;

public class ReflectField {

    /**
     * 反射测试字段（属性）的值
     * public int address
     * @throws Exception
     */
    @Test
    public void reflect1 () throws Exception {
        Class cls = Class.forName("reflect.Person");
        Field field = cls.getField("address");
        String result = field.getName();
        System.out.println("反射所得的字段的结果是："+result);
    }

    /**
     * 反射测试私有的属性（字段）的结果
     * private String name
     * @throws Exception
     */
    @Test
    public void reflect2() throws Exception {
        Class cls = Class.forName("reflect.Person");
        Field field = cls.getDeclaredField("name");
        field.setAccessible(true);
        String result = field.getName();
        System.out.println("反射测试所得的私有的字段（属性）的值为："+ result);
    }

}

---

我的总结

---

• 全部的反射方法均交给JUnit测试通过，并没有发现出错的地方
• 反射是一个比较灵活的方式，具体情况一定要灵活的变通
• 对于私有的变量或者方法，要想访问到其值，就必须打开访问的权限即设置为setAccessable(true)；
• 对于框架的运行，需要给出一个类的完整名称（包含完整的包名）,这样才不会出错！