Java反射 #

// 方式1：类名.class
Class<String> clazz1 = String.class;

// 方式2：对象.getClass()
String str = "Hello";
Class<?> clazz2 = str.getClass();

// 方式3：Class.forName()
Class<?> clazz3 = Class.forName("java.lang.String");

// 方式4：类加载器
Class<?> clazz4 = ClassLoader.getSystemClassLoader().loadClass("java.lang.String");

Class<?> clazz = String.class;

// 基本信息
clazz.getName();          // java.lang.String
clazz.getSimpleName();    // String
clazz.getPackage();       // package java.lang
clazz.getSuperclass();    // class java.lang.Object
clazz.getInterfaces();    // 实现的接口
clazz.getModifiers();     // 修饰符

// 判断
clazz.isInterface();      // 是否接口
clazz.isArray();          // 是否数组
clazz.isEnum();           // 是否枚举
clazz.isAnnotation();     // 是否注解

Class<?> clazz = Person.class;

// 获取所有public构造方法
Constructor<?>[] constructors = clazz.getConstructors();

// 获取所有构造方法
Constructor<?>[] allConstructors = clazz.getDeclaredConstructors();

// 获取指定构造方法
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);

// 获取私有构造方法
Constructor<?> privateConstructor = clazz.getDeclaredConstructor(String.class);
privateConstructor.setAccessible(true);  // 设置可访问

Class<?> clazz = Person.class;

// 获取所有public字段
Field[] fields = clazz.getFields();

// 获取所有字段
Field[] allFields = clazz.getDeclaredFields();

// 获取指定字段
Field nameField = clazz.getField("name");
Field privateField = clazz.getDeclaredField("age");
privateField.setAccessible(true);

Class<?> clazz = Person.class;

// 获取所有public方法
Method[] methods = clazz.getMethods();

// 获取所有方法
Method[] allMethods = clazz.getDeclaredMethods();

// 获取指定方法
Method method = clazz.getMethod("setName", String.class);
Method privateMethod = clazz.getDeclaredMethod("privateMethod");
privateMethod.setAccessible(true);

Class<?> clazz = Person.class;

// 无参构造
Person person = (Person) clazz.getDeclaredConstructor().newInstance();

// 有参构造
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
Person person2 = (Person) constructor.newInstance("张三", 25);

Class<?> clazz = Person.class;

Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);
constructor.setAccessible(true);  // 私有构造
Person person = (Person) constructor.newInstance("张三");

public class Person {
    private String name;
    public int age;
}

Person person = new Person();
Class<?> clazz = person.getClass();

// 获取public字段
Field ageField = clazz.getField("age");
ageField.set(person, 25);
int age = (int) ageField.get(person);

// 获取private字段
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(person, "张三");
String name = (String) nameField.get(person);

Field field = clazz.getDeclaredField("name");

Class<?> type = field.getType();
System.out.println(type.getName());  // java.lang.String

// 判断类型
if (field.getType() == String.class) {
    // 字符串类型
}

public class Person {
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    private void privateMethod() { }
}

Person person = new Person();
Class<?> clazz = person.getClass();

// 调用public方法
Method setName = clazz.getMethod("setName", String.class);
setName.invoke(person, "张三");

Method getName = clazz.getMethod("getName");
String name = (String) getName.invoke(person);

// 调用private方法
Method privateMethod = clazz.getDeclaredMethod("privateMethod");
privateMethod.setAccessible(true);
privateMethod.invoke(person);

public class Utils {
    public static int add(int a, int b) {
        return a + b;
    }
}

Method method = Utils.class.getMethod("add", int.class, int.class);
int result = (int) method.invoke(null, 10, 20);  // 静态方法，对象传null

Method main = clazz.getMethod("main", String[].class);
main.invoke(null, (Object) new String[]{"arg1", "arg2"});

public class Factory {
    @SuppressWarnings("unchecked")
    public static <T> T create(String className) {
        try {
            Class<?> clazz = Class.forName(className);
            return (T) clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// 使用
Person person = Factory.create("com.example.Person");

public static void copyProperties(Object source, Object target) {
    Class<?> sourceClass = source.getClass();
    Class<?> targetClass = target.getClass();
    
    for (Field sourceField : sourceClass.getDeclaredFields()) {
        try {
            Field targetField = targetClass.getDeclaredField(sourceField.getName());
            sourceField.setAccessible(true);
            targetField.setAccessible(true);
            targetField.set(target, sourceField.get(source));
        } catch (NoSuchFieldException e) {
            // 忽略不存在的字段
        }
    }
}

public static void processAnnotations(Object obj) {
    Class<?> clazz = obj.getClass();
    
    for (Method method : clazz.getDeclaredMethods()) {
        if (method.isAnnotationPresent(Log.class)) {
            Log log = method.getAnnotation(Log.class);
            System.out.println("方法 " + method.getName() + " 有日志注解: " + log.value());
        }
    }
}

// 缓存Method对象
private static final Map<String, Method> METHOD_CACHE = new ConcurrentHashMap<>();

public static Method getMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
    String key = clazz.getName() + "." + name;
    return METHOD_CACHE.computeIfAbsent(key, k -> {
        try {
            return clazz.getMethod(name, paramTypes);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    });
}

// 使用setAccessible提高性能
method.setAccessible(true);