反射

反射

什么是反射？
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

简单来说，就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

那么如何获得到class对象呢？
获取class文件对象的方式：
A:Object类的getClass()方法
B:数据类型的静态属性class
C:Class类中的静态方法
public static Class forName(String className)
开发中一般推荐第第三种，为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
获得class对象代码体现

编写一个普通的person类

package cn.itcast_01;

public class Person {
    //三个不同修饰权限的变量
    private String name;
    int age;
    public String address;
    //无参构造
    public Person() {
    }
    //私有带参构造
    private Person(String name) {
        this.name = name;
    }
    //默认带双参构造
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //带三个参数的构造
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //普通成员方法
    public void show() {
        System.out.println("show");
    }
    //带参成员方法
    public void method(String s) {
        System.out.println("method " + s);
    }
    //带双参有返回值的成员方法
    public String getString(String s, int i) {
        return s + "---" + i;
    }
    //私有无参无返回值方法
    private void function() {
        System.out.println("function");
    }

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

}

类加载对象是同一个对象的代码说明

package cn.itcast_01;
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 方式1
        Person p = new Person();
        Class c = p.getClass();

        Person p2 = new Person();
        Class c2 = p2.getClass();

        System.out.println(p == p2);// false，由于开辟了不同的的堆内存空间，所以是false
        System.out.println(c == c2);// true，从这里可以看出，得出的是同一个class对象

        // 方式2
        Class c3 = Person.class;
        // int.class;
        // String.class;
        System.out.println(c == c3);//true

        // 方式3
        // ClassNotFoundException
        Class c4 = Class.forName("cn.itcast_01.Person");
        System.out.println(c == c4);//true
    }
}

通过反射获取构造方法

• 获取所有构造方法
  分别得到构造方法的数组对象。
  public Constructor[] getConstructors():所有公共构造方法
  public Constructor[] getDeclaredConstructors():所有构造方法

• 获取单个构造方法
  public Constructor getConstructor(Class《?》… parameterTypes)
  参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象

通过获得带参构造，创建对象，并初始化值

package cn.itcast_02;
import java.lang.reflect.Constructor;

public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("cn.itcast_01.Person");
        // 获取带参构造方法对象
        // public Constructor<T> getConstructor(Class<?>... parameterTypes)
        Constructor con = c.getConstructor(String.class, int.class,
                String.class);
        // 通过带参构造方法对象创建对象
        // public T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞", 27, "北京");
        System.out.println(obj);
    }
}

• 创建对象实例
  public T newInstance(Object… initargs)
  使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

通过获得无参构造，来创建对象。

package cn.itcast_02;
import java.lang.reflect.Constructor;
import cn.itcast_01.Person;
/*
 * 通过反射获取构造方法并使用。
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
        //获取无参构造
        Constructor con = c.getConstructor();// 返回的是构造方法对象
        Object obj = con.newInstance();//等同于 Person p = new Person();
        System.out.println(obj);
    }
}

• 获得私有构造并使用

public Constructor《T》 getDeclaredConstructor(Class《?》… parameterTypes)

获得私有构造方法并使用

package cn.itcast_02;
import java.lang.reflect.Constructor;

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
        // 获取私有构造方法对象
        Constructor con = c.getDeclaredConstructor(String.class);

        // 用该私有构造方法创建对象
        // 获取的当前对象，仍然没有权限去创建实例对象，所以需要手动开启，否则会报IllegalAccessException:非法的访问异常。
        // 暴力访问
        con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
        Object obj = con.newInstance("风清扬");

        System.out.println(obj);
    }
}

通过反射获得成员变量

• 获得所有成员变量
  Field[] fields = c.getFields();//不包括私有的
  Field[] fields = c.getDeclaredFields();//包括私有的

• 为成员变量赋值
  第一个参数表示当前对象，第二个表示要附的值
  public void set(Object obj,Object value)

获得私有成员变量，无修饰符的成员变量和公共的成员变量代码体现

package cn.itcast_03;

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

/*
 * 通过发生获取成员变量并使用
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");

        // 通过无参构造方法创建对象，先要获得对象的实例
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        // 获取公共的变量address并对其赋值
        Field addressField = c.getField("address");
        addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
        System.out.println(obj);

        // 获取私有的变量name并对其赋值
        Field nameField = c.getDeclaredField("name");
        //同样这里也没有权限为私有变量赋值，需要手动开启权限，否则会报IllegalAccessException
        nameField.setAccessible(true);
        nameField.set(obj, "林青霞");
        System.out.println(obj);

        // 获取age并对其赋值，这里就类似于一个公共的方法，不管什么变量，都通过getDeclaredField来获得，并且直接开启权限
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj, 27);
        System.out.println(obj);
    }
}

通过反射来获取成员方法

• 获得成员方法
  Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法

• 获取单个方法
  第一个参数表示获得哪一个方法的方法名，第二个参数表示获得当前方法的参数列表
  public Method getMethod(String name,Class《?》… parameterTypes)

• 获得私有的成员方法
  public Method getDeclaredMethod(String name,Class《?》… parameterTypes)

• 调用该方法
  第一个参数表示当前对象的实例，第二个表示对该方法传递的参数值
  public Object invoke(Object obj,Object… args)

调用各个方法的代码体现

package cn.itcast_04;

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

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        //获得类对象的实例
        Class c = Class.forName("cn.itcast_01.Person");
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
        //获得无参的成员方法
        Method m1 = c.getMethod("show");
        // 调用obj对象的方法，由于是无参，所以不需要添加参数
        m1.invoke(obj); 

        //获得带一个String类型参数的方法
        Method m2 = c.getMethod("method", String.class);
        m2.invoke(obj, "hello");

        //获得带两个参数，String，int；并且有返回值的方法
        Method m3 = c.getMethod("getString", String.class, int.class);
        Object objString = m3.invoke(obj, "hello", 100);//直接接受返回值输出
        System.out.println(objString);
        // String s = (String)m3.invoke(obj, "hello",100);也可以强转为原来类的返回值类型输出
        // System.out.println(s);

        // 获得私有的成员方法
        Method m4 = c.getDeclaredMethod("function");
        //同样的开启权限
        m4.setAccessible(true);
        m4.invoke(obj);
    }
}

练习题

如何在ArrayList《Integer》中添加一个String类型的数据？
下图是将一个ArrayList《Integer》添加一个数据的.JAVA文件，通过反编译器查看得到的源码。并且由于泛型的新特性是个编译器看的，真正运行时，泛型将不存在，所以我要是能拿到该类的源码。忽略泛型即可添加

package cn.itcast.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> array = new ArrayList<Integer>();

        Class c = array.getClass(); // 获得集合ArrayList的class文件对象
        Method m = c.getMethod("add", Object.class);//获得ArrayList集合中的add方法

        m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
        m.invoke(array, "world");
        m.invoke(array, "java");

        System.out.println(array);
    }
}