【JAVA基础】- 反射

反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法.

获取class文件对象(三种方法)

        // 获取class文件对象
        // 第一种 数据类型的静态属性class
        Class<Person> personClass = Person.class;

        // 第二种 Object类的getClass()方法
        Person person = new Person();
        Class<? extends Person> personClass2 = person.getClass();
        // 第三种 Class类中的静态方法
        Class<?> personClass3 = Class.forName("top.lconcise.demo.Person");

通过反射获取构造方法并使用

    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class<?> personClass = Class.forName("top.lconcise.demo.Person");
        // 获取公有的无参构造方法
        Constructor<?> constructor = personClass.getConstructor();

        Object person = constructor.newInstance();
        System.out.println(person);
        // 获取私有的有参构造方法
        Constructor<?> declaredConstructor = personClass.getDeclaredConstructor(String.class);
        // 暴力访问
        declaredConstructor.setAccessible(true);
        Object person2 = declaredConstructor.newInstance("张小龙");
        System.out.println(person2);
    }

通过反射获取成员变量并为其赋值

    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class<?> personClass = Class.forName("top.lconcise.demo.Person");
        // 获取无参构造方法
        Constructor<?> constructor = personClass.getConstructor();
        // 创建对象
        Object person = constructor.newInstance();
        // 获取成员变量并赋值
        Field usernameField = personClass.getDeclaredField("username");
        usernameField.setAccessible(true);
        usernameField.set(person, "张小龙");

        System.out.println(person);
    }

获取成员方法，并执行方法

    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class<?> aClass = Class.forName("top.lconcise.demo.Person");
        // 获取无参构造方法
        Constructor<?> constructor = aClass.getConstructor();
        // 创建一个对象
        Object obj = constructor.newInstance();

        // 获取成员方法，并执行方法
        Method method = aClass.getMethod("method");
        Method method2 = aClass.getMethod("method2", String.class);
        Method method3 = aClass.getDeclaredMethod("method3", String.class);

        method.invoke(obj);
        method2.invoke(obj, "hello");
        method3.setAccessible(true);
        method3.invoke(obj, "hello");
    }

Demo(1)

/**
 * Created by liusj on 2019/5/10
 * <p>
 * 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法.
 *
 * List 集合中添加元素的两种方法
 */
public class ReflectDemo {

    public static void main(String[] args) throws Exception {
        List<String> list = new ArrayList<>();

        list.add("hello");
        list.add("world");

        Class<? extends List> aClass = list.getClass();
        Method method = aClass.getMethod("add", Object.class);
        method.invoke(list, "java");

        System.out.println(list);

        // 获取class文件对象
        // 第一种 数据类型的静态属性class
        Class<Person> personClass = Person.class;

        // 第二种 Object类的getClass()方法
        Person person = new Person();
        Class<? extends Person> personClass2 = person.getClass();
        // 第三种 Class类中的静态方法
        Class<?> personClass3 = Class.forName("top.lconcise.demo.Person");


        System.out.println(personClass == personClass2);
        System.out.println(personClass2 == personClass3);
    }
}

Demo(2)

/**
 * Created by liusj on 2019/5/13
 * <p>
 * 通过反射给对象的成员变量赋值.
 */
public class ReflectTool {

    public void setProperty(Object obj, String propertyName, Object value)
            throws NoSuchFieldException, IllegalAccessException {
        // 根据对象获取字节码文件对象
        Class<?> aClass = obj.getClass();
        // 获取对象的propertyName成员变量
        Field declaredField = aClass.getDeclaredField(propertyName);
        // 取消访问检查
        declaredField.setAccessible(true);
        // 给对象的成员变量赋值
        declaredField.set(obj, value);
    }
}