第十章 反射

获取Class方式

// 1. forName 静态方法,会触发static{}静态代码块执行
Class.forName("java.lang.String");

User user = new User();
// 2. 实例方法
Class<? extends User> aClass = user.getClass();

// 3. 类 class 属性 不会触发static{}静态代码块执行
Class<User> userClass = User.class;

// 4. 使用ClassLoader  不会触发static{}静态代码块执行
Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("com.test.package1.User");

• 获取类应用加载器

// 通过ClassLoader
ClassLoader.getSystemClassLoader();
// 通过类getClassLoader
Class.forName("com.test.package1.User").getClassLoader();
// 通过Thread
Thread.currentThread().getContextClassLoader();

• 实例化（从java9开始废弃），推荐使用反射构造器进行实例化

className = "cn.test.o01.User";
Class<User> userClass = (Class<User>) Class.forName(className);
// 实例化类 从java9开始废弃
User user = userClass.newInstance();
System.out.println(user);

• 获取类属性/字段

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


        Class<?> aClass = Class.forName("cn.sdy.oo1.User");

        // 获取类的父类
        aClass.getSuperclass();

        // 获取类的所有接口
        aClass.getInterfaces();

        // 获取类的完整类名
        aClass.getName();
        // 获取不带包名类名
        aClass.getSimpleName();

        // 获取类中所有public的属性/字段
        Field[] fields = aClass.getFields();

        // 获取类中所有的属性/字段
        Field[] declaredFields = aClass.getDeclaredFields();
        // 遍历字段
        for (Field declaredField : declaredFields) {
            // 字段名
            declaredField.getName();
            // 字段类型 返回Class类型
            declaredField.getType();
            // 字段修饰符 返回int
            declaredField.getModifiers();
            // 字段修饰符 转为语义化 public static final
            Modifier.toString(declaredField.getModifiers());
        }

        // 获取指定属性/字段
        Field sex = aClass.getDeclaredField("sex");
        // 私有属性/字段需要设置权限
        sex.setAccessible(true);
        User user = new User();
        // 设置对象字段值
        sex.set(user, 2);
        // 获取对象字段值
        sex.get(user);

        // 获取类的所有方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            // 方法修饰符
            Modifier.toString(method.getModifiers());
            // 方法返回类型
            method.getReturnType();
            // 方法名
            method.getName();
            // 方法参数列表
            Parameter[] parameters = method.getParameters();
            for (Parameter parameter : parameters) {
                // 参数类型
                parameter.getType();
                // 参数名
                parameter.getName();
            }
        }

        // 获取指定方法：由于方法可以重载，所以方法名和参数类型要一一对应，才能找到对应的方法。
        Method isOk = aClass.getDeclaredMethod("isOk", String.class);
        // 私有方法设置权限爆破
        isOk.setAccessible(true);
        // 调用对象方法
        isOk.invoke(user, "aa");

        // 获取类的所有构造方法
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        // 获取指定构造方法
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);
        // 实例化对象 newInstance 从java9开始废弃
        // aClass.newInstance();
        // 实例化对象
        Object o = declaredConstructor.newInstance("新的");

        // 获取泛型
        // 获取构造方法
        Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(Map.class);
        declaredConstructor.setAccessible(true);
        // 获取构造方法的入参泛型
        Type[] genericParameterTypes = declaredConstructor.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            if (genericParameterType instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
                System.out.println(parameterizedType.getTypeName());
            }
        }

        // 获取方法
        Method m = userClass.getDeclaredMethod("m", List.class);
        m.setAccessible(true);
        // 获取方法的入参泛型
        Type[] genericParameterTypes1 = m.getGenericParameterTypes();
        for (Type genericParameterTypes2 : genericParameterTypes) {
            if (genericParameterTypes2 instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) genericParameterTypes2;
                System.out.println(parameterizedType.getTypeName());
            }
        }

        // 获取方法的返回泛型
        Type genericReturnType = m.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) genericReturnType;
            System.out.println(parameterizedType.getTypeName());
        }

    }
}

class User {
    public String name = "aa";
    Boolean ok;
    private int sex;
    public static final String like = "爱好";

    public boolean isOk(String name) {
        return name.equals(this.name);
    }

    public List<String> m(List<String> list) {
        return list;
    }

    public User() {
    }

    private User(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", ok=" + ok +
                ", sex=" + sex +
                '}';
    }
}