Java 反射的入门用法示例

前言：反射:动态获取类 （字节码文件 如本篇中的Person.class）,并对其成员进行运行。反射在Android应用层的开发中可能遇到会稍微少一点，但对于想打通底层的小伙伴来说，必须要熟练掌握运用。
原文出处：http://blog.csdn.net/u014158743/article/details/52939229

实体类

Person.java

package com.sunwenou.reflect;// 包名

public class Person {

    private String name;
    private int age;

    public  Person() {// 无参

    }

    public Person(String name, int age) {// 带参
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return name+","+age;
    }

    public void show() { // 空参
        System.out.println("show");
    }

    public void fun(String ss) { // 带参
        System.out.println(ss);
    }

    public static void function() { // 静态
        System.out.println("static");
    }

}

---

动态获取字节码文件的方法

本篇中为使博文看起来简介，一概抛出Exception，并省略import，下同。

package com.sunwenou.reflect;

public class Demo1 {

    /**
     * 动态获取字节码文件的方法
     * 1:使用Object类提供的 Class getClass()方法
     *   这种方法需要对象
     * 2:每种数据类型都有一个静态的class属性,这个属性返回的这种数据类型所属字节码文件对象
     *   int.class   Person.class
     * 3:使用 Class提供的 forName()方法
     *   只需要提供一个字符串，这个字符串由 包名+类名 构成
     */
    public static void main(String[] args) throws Exception {
        //getClaz();

        //getCalz2();

        getClaz3();

    }
    //使用 Class提供的 forName()方法
    public static void getClaz3() throws Exception {
        Class<?> claz = Class.forName("com.sunwenou.reflect.Person");
        Class<?> claz2 = Class.forName("com.sunwenou.reflect.Person");

        System.out.println(claz==claz2);
    }
    //每种数据类型都有一个静态的class属性
    public static void getCalz2() {
        Class<Person> p1 = Person.class;
        Class<Person> p2 = Person.class;

        System.out.println(p1==p2);
    }
    //使用Object类提供的 Class getClass()方法
    public static void getClaz() {
        Person person1 = new Person();
        Class<? extends Person> claz = person1.getClass();//Person.class

        Person person2 = new Person();
        Class<? extends Person> claz2 = person2.getClass();//Person.class

        System.out.println(claz==claz2);

    }

}

---

动态获取类，并创建对象

package com.sunwenou.reflect;
public class Demo2 {

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

        //createObj();

        createObj2();
    }

    public static void createObj2() throws Exception {
        //Person person = new Person("lisi",23);
        //得到字节码文件对象
        Class<?>  claz = Class.forName("com.sunwenou.reflect.Person");//Person.class

        //得到带参数的构造方法所属的Constructor类型的对象
        Constructor constructor = claz.getConstructor(String.class,int.class);

        //使用Constructor类提供的创建对象的方法创建对象
        Person person = (Person)constructor.newInstance("lisi",23);

        System.out.println(person);

    }

    public static void createObj() throws Exception {
        //Person person = new Person();
        //得到字节码文件对象
        Class<?>  claz = Class.forName("com.sunwenou.reflect.Person");

        Object obj = claz.newInstance();//默认使用空参的构造方法创建对象

        System.out.println(obj);
    }

}

---

动态获取类并为成员变量赋值

package com.sunwenou.reflect;
public class Demo3 {

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

        //Person p = new Person();
        //p.name = "lisi";
        //得到字节码文件对象
        Class<?>  claz = Class.forName("com.sunwenou.reflect.Person");
        //得到成员变量所属的Field类型的对象
        //Field field = claz.getField("name");//得到的是public权限的成员
        Field field = claz.getDeclaredField("name");//得到所有声明的字段
        System.out.println(field);

        //非静态成员变量是依赖于对象的
        Object obj = claz.newInstance();

        field.setAccessible(true);//暴力破解, 设置为可访问的
        field.set(obj, "张三");

        System.out.println(obj);
    }

}

---

动态获取类，并执行方法

package com.sunwenou.reflect;
public class Demo4 {
    public static void main(String[] args) throws Exception {

        //method1();

        method2();

        method3();

    }
    public static void method3() throws Exception {
        //得到字节码文件对象
        Class<?>  claz = Class.forName("com.sunwenou.reflect.Person");

        Method m = claz.getMethod("function", null);

        m.invoke(null, null);


    }
    ////执行带参数的方法
    public static void method2() throws Exception {
        //得到字节码文件对象
        Class<?>  claz = Class.forName("com.sunwenou.reflect.Person");

        Method m = claz.getMethod("fun", String.class);

        Object obj = claz.newInstance();

        m.invoke(obj, "hello");

    }

    //执行无参的方法
    public static void  method1() throws Exception {
        //Person person = new Person(); person.show();
        //得到字节码文件对象
        Class<?>  claz = Class.forName("com.sunwenou.reflect.Person");

        //得到被执行的方法所属的字节码文件对象
        Method m = claz.getMethod("show", null);

        //非静态方法是依赖于对象的
        Object obj = claz.newInstance();

        //执行方法
        m.invoke(obj, null);
    }

}

---

这就是反射的基本用法，我们就可以在不能通过正常创建对象的时候通过对象的字节码文件来创建对象，并执行其中的方法，你学会了吗？？