反射

反射

**定义：**在运行期间，可以期间可以获得对象的类型，类型的方法、类型的属性、类型的构造方法等等，让对象可以认识自身的结构

获取对象的类型（类对象）

方式1： Object.getClass()
方式2： Class.forName(“类名”)
方式3： 类名.class

类对象的功能

1）用反射的方式创建对象

正常创建对象： new 类名（）；
反射创建对象： 类对象.newInstance（）；//创建一个新实列（对象）

2）获取方法信息

类对象.getMethod(); //获取所有公共方法（public），包括继承的
类对象.getDeclaredMethods();//获取本类的所有方法，报货私有

类对象.getMethod(方法名，参数类型);
类对象.getDeclaredMethods(方法名参数类型);

3)获取属性信息

类对象.getFields（）；获取所有公共属性，包括继承
类对象.getDeclaredFields(); // 获取本类所有属性（private public protected 不加）（不包括继承的）
类对象.getField(“属性名”);
类对象.getDeclaredField(“属性名”);

4)获取构造方法

类对象.getConstructors（）；获取所有公共的构造方法，包括继承
类对象.getDeclaredConsttructors（）//获取本类的构造方法包括私有
类对象.getConstructor(int.class); // 获取int参数类型的构造
类对象.getConstructor(); // 获得无参构造

5）反射调用方法

正常调用方式：对象.invoke（对象，参数）
反射调用方式：方法.invoke(对象，参数)
缺点：调用复杂，效率低
优点：可以调用私有方法，突破正常方法的限制，（经常在开源框架中）

补充：

1、//反射创建对象，newInstance（）限制1：要求对象有无惨构造 限制2：构造方法不能私有

2、 m1.setAccessible(true); 、、私有方法要经过 方法.setAccessible(true);默认为false要设置为true才能使用

package src.reflect;

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

public class TestReflect {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        // 方法1
//        System.out.println(new User().getClass());

        // 方法2
        System.out.println(Class.forName("reflect.User"));

        // 这个类型信息在jvm仍表现为一个对象，而且只有一份
//        System.out.println(new User().getClass() == Class.forName("reflect.User"));

        // 方法3
        System.out.println(User.class);

        // 反射创建对象, newInstance() 限制1： 要求对象有无参构造  限制2： 构造方法不能私有
        User user = User.class.newInstance();
        System.out.println(user);

        // 获取方法信息
        Method[] methods = User.class.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("============================");

//        Method m = User.class.getMethod("m1");
//        System.out.println(m);

        System.out.println("============================");
        Field[] fields = User.class.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("=============================");
        User u = new User();
//        u.m1(); // 正常调用方法

        // 方法.invoke(对象， 参数);
        Method m1 = User.class.getDeclaredMethod("m1");
        m1.setAccessible(true); // 设置这个方法可以被访问，可以突破访问修饰符的限制
        m1.invoke(u); // 反射调用方法（性能低）

        // 反射调用 public void m1(int a)
        Method m12 = User.class.getDeclaredMethod("m1", int.class);
        m12.invoke(u, 1);

        Method m13 = User.class.getDeclaredMethod("m1", int.class, int.class);
        m13.invoke(u, 4, 5);

        // 调用私有构造
        Constructor<Student> cons = Student.class.getDeclaredConstructor();
        cons.setAccessible(true);
        Student s = cons.newInstance();
        System.out.println(s);
    }
}