java的反射技术_反射技术_android 反射技术

java的反射机制

我们都知道，一个java类中，有成员变量、成员方法、构造方法等等，反射机制，就是动态的获取这些类中的信息，并动态的调用对象的方法。通常只有要设计框架的过程中，才会使用java反射相关的api，但是了解java反射机制的基本原理与基本方法，可以帮忙我们在日后对框架的学习与应用提供很大的帮忙。

了解Class类：

Class类代表着某个类的字节码，要使用反射，就需要取得对应的Class对象，然后就通过这个对象，就可解剖出类的成员变量，成员方法等等。

Class类的常用方法：

getConstructor() 获取构造函数

getMethod() 获取成员方法

getField() 获取成员变量

getDeclaredConstructor() 获取私有的构造函数

getDeclaredMethod() 获取私有的成员方法

getDeclaredField() 获取私有的成员变量

如何获取Class类对象：

//通过Class的forName()方法,此方法最为常用
Class class1 = Class.forName("com.java4fun.reflect.Person");
//通过 Person.class
Class class2 = Person.class;
//通过对象获得
Class class3 = new Person().getClass();

反射的使用，简单的讲，就是通过类的Class对象，获取对应的Field、Method 和 Constructor 对象，并进行相关操作。

下面就用反射来解剖Person类，给出Person类：

public class Person {

    public String name = "java";
    private int age = 2013;

    // 无参构造函数
    public Person() {
    }

    public Person(int age) {
        super();
        this.age = age;
    }

    // 私有构造函数
    private Person(String name) {
        super();
        this.name = name;
    }

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

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

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

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

    public static void getMessage(String message) {
        System.out.println(message);
    }

    public static void getFriends(String friends[]) {
        for (String s : friends) {
            System.out.print(s + " ");
        }
    }

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

    private void secret(String secret) {
        System.out.println(secret);
    }

    public void run(int num) {
        System.out.println(num);
    }
}

构造函数的获取：

public class ConstructorTest {
    // 利用反射技术，完成对Person.类的相关操作
    public static void main(String[] args) throws Exception {
        constructor1(); // 无参构造函数的获取与使用
        constructor2(); // 带参数的构造函数的获取使用
        constructor3(); // 私有的构造函数的获取使用
    }

    // 获取私有构造函数
    private static void constructor3() throws Exception {
        // 获取Person的字节码对象。
        Class clazz = Class.forName("com.java4fun.reflect.Person");
        // 获取私有构造函数对象。
        Constructor c = clazz.getDeclaredConstructor(String.class);
        // 由于私有的构造函数无数直接构造对象,需要调用setAccessible()，
        // 此方法来自于AccessibleObject 类，它是 Field、Method 和 Constructor 对象的基类
        c.setAccessible(true);
        // 利用这个构造函数，构造一个Person对象
        Person p = (Person) c.newInstance("private constructor");
        System.out.println(p);
    }

    // 访问带参数的构造函数
    private static void constructor2() throws Exception {
        // 获取Person的字节码对象。
        Class clazz = Class.forName("com.java4fun.reflect.Person");
        // 获取带参数的构造函数对象。
        Constructor c = clazz.getConstructor(String.class, int.class);
        // 利用这个构造函数，构造一个Person对象
        Person p = (Person) c.newInstance("hello", 110);
        System.out.println(p);
    }

    // 访问无参构造函数
    private static void constructor1() throws Exception {
        // 获取Person的字节码对象。
        Class clazz = Class.forName("com.java4fun.reflect.Person");
        // 获取无参的构造函数对象。
        Constructor c = clazz.getConstructor(null);
        // 利用这个构造函数，构造一个Person对象
        Person p = (Person) c.newInstance(null);
        System.out.println(p);

        // Class类也提供了一个可直接用无参构造函数构造对象的方法
        // Person person = (Person) clazz.newInstance();
        // System.out.println(person);
    }
}

成员方法的获取：

public class MethodTest {
  // 利用反射技术，完成对Person.类的相关操作
  public static void main(String[] args) throws Exception {
    // method1(); //无参成员方法的获取与使用
    // method2(); // 带参数成员方法的获取使用
    // method3(); // 私有成员方法的获取使用
    method4(); // 参数是数组的方法解决方法
  }

  // 获取无参成员方法
  private static void method1() throws Exception {
    // 获取Person的字节码对象。
    Class clazz = Class.forName("com.java4fun.reflect.Person");
    // 获取无参的方法， 反射Person类的中 public String getName(){}方法
    Method m = clazz.getMethod("getName", null);
    // 运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。
    Person p = new Person("HelloWorld", 23);
    String name = (String) m.invoke(p, null);
    System.out.println(name);
  }

  // 获取带参数的成员方法
  private static void method2() throws Exception {
    // 获取Person的字节码对象。
    Class clazz = Class.forName("com.java4fun.reflect.Person");
    // 获取带参数的方法， 反射Person类的中 public void run(int num){}方法
    Method m = clazz.getMethod("run", int.class);
    // 运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。
    Person p = new Person("HelloWorld", 23);
    m.invoke(p, 11111);
  }

  // 获取私有的成员方法
  private static void method3() throws Exception {
    // 获取Person的字节码对象。
    Class clazz = Class.forName("com.java4fun.reflect.Person");
    // 获私有的方法， 反射Person类的中 private void secret(String secret){}方法
    Method m = clazz.getDeclaredMethod("secret", String.class);
    // 让私有方法可以访问
    m.setAccessible(true);
    // 运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。
    Person p = new Person("HelloWorld", 23);
    m.invoke(p, "最近变胖了");
  }

  // 参数是数组的方法解决方法
  private static void method4() throws Exception {
    // 获取Person的字节码对象。
    Class clazz = Class.forName("com.java4fun.reflect.Person");
    // 获静态方法， 反射Person类的中 public static void getFriends(String
    // friends[]){}方法
    Method m = clazz.getMethod("getFriends", String[].class);

    // 这样调用方法会出错，由于版本的遗留问题，new String[]{"java","c","c++"}会被认为是"java" "c"
    // "c++"
    // m.invoke(null, new String[]{"java","c","c++"});
    // 相当于getFriends("java","c","c++");

    // 正确调用方法,相当于把数组当成一个对象传入
    m.invoke(null, (Object) new String[] { "java", "c", "c++" });
  }
}

成员属性的获取：

public class FieldTest {
    // 利用反射技术，完成对Person.类的相关操作
    public static void main(String[] args) throws Exception {
        method1(); // 获取属性
        method2(); // 获取私有属性
    }

    // 获取属性
    private static void method1() throws Exception {
        // 获取Person的字节码对象。
        Class clazz = Class.forName("com.java4fun.reflect.Person");
        // 获取属性， 反射Person类的中 public String name = "java";属性
        Field f = clazz.getField("name");
        // 使用属性，需指定对象,为了方便，在这里直接通过传统的方法创建一个对象。
        Person p = new Person();
        Class type = f.getType();
        if (type.equals(String.class)) {
            String name = (String) f.get(p);
            System.out.println(name);
        }
    }

    // 获取私有属性
    private static void method2() throws Exception {
        // 获取Person的字节码对象。
        Class clazz = Class.forName("com.java4fun.reflect.Person");
        // 获取私有属性， 反射Person类的中 private int age = 2013;属性
        Field f = clazz.getDeclaredField("age");
        f.setAccessible(true);
        // 使用属性，需指定对象,为了方便，在这里直接通过传统的方法创建一个对象。
        Person p = new Person();
        Class type = f.getType();
        if (type.equals(int.class)) {
            int age = f.getInt(p);
            System.out.println(age);
        }
    }
}