Person person = new Person();
person.setName("Alice");

Class<?> clazz = Class.forName("Person");
Object person = clazz.newInstance();
Method setNameMethod = clazz.getMethod("setName", String.class);
setNameMethod.invoke(person, "Alice");

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {
}

public class ClassUniqueDemo {

    public static void main(String[] args) {
        // 创建多个实例对象
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);

        // 获取 Class 对象
        Class<?> class1 = person1.getClass();
        Class<?> class2 = person2.getClass();
        Class<?> class3 = Person.class;

        // 打印 Class 对象的哈希码
        System.out.println("class1: " + class1.hashCode());
        System.out.println("class2: " + class2.hashCode());
        System.out.println("class3: " + class3.hashCode());

        // 验证所有实例对象的 Class 对象是否相同
        System.out.println("class1 == class2: " + (class1 == class2));
        System.out.println("class1 == class3: " + (class1 == class3));
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
Class<?> clazz = classLoader.loadClass("com.example.MyClass");

Constructor<?> constructor = clazz.getConstructor();
Object instance = constructor.newInstance();

public Class<?>[] getInterfaces()

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = Class.forName("com.example.codingInAction.reflectionPractice.Person");

            // 获取所有构造函数
            Constructor<?>[] constructors = clazz.getDeclaredConstructors();
            for (Constructor<?> constructor : constructors) {
                System.out.println("Constructor: " + constructor);
            }
            // 获取无参构造函数
            Constructor<?> constructor1 = clazz.getDeclaredConstructor();

            System.out.println("Constructor1: " + constructor1);

            Constructor<?> constructor2 = clazz.getDeclaredConstructor(String.class);
            System.out.println("Constructor2: " + constructor2);


            Constructor<?> constructor3 = clazz.getDeclaredConstructor(int.class);
            System.out.println("Constructor3: " + constructor3);

            Constructor<?> constructor4 = clazz.getConstructor(String.class, int.class);
            System.out.println("Constructor4: " + constructor4);

            Object alex = constructor4.newInstance("Alex", 30);
            System.out.println(alex);


            // 获取所有方法
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println("Method: " + method);
            }

            // 获取指定名称和参数类型的声明的方法
            Method setAgeMethod = clazz.getDeclaredMethod("setAge", int.class);
            System.out.println("Method: " + setAgeMethod);

            // 如果是私有方法，需要设置成 可访问
            // setAgeMethod.setAccessible(true);

            setAgeMethod.invoke(alex, 35);

            Method getAgeMethod = clazz.getDeclaredMethod("getAge");

            int age = (Integer) getAgeMethod.invoke(alex);

            System.out.println("alex's age is " + age);


            // 获取所有字段
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                System.out.println("Field: " + field);
            }

            // 获取指定名称的声明的字段
            Field ageField = clazz.getDeclaredField("age");
            System.out.println("Field: " + ageField);
            //如果是private, 需要设置成 “可访问”
             ageField.setAccessible(true);

            System.out.println("Age: " + ageField.get(alex));

        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException |
                 InvocationTargetException | InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        }
    }
}

@CallerSensitive
@ForceInline // to ensure Reflection.getCallerClass optimization
@HotSpotIntrinsicCandidate
public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
{
    // 检查是否需要进行访问控制检查
    if (!override) {
        // 获取调用者的类
        Class<?> caller = Reflection.getCallerClass();
        // 检查访问权限，检查调用者是否有权限调用目标方法。如果目标方法是静态的，则第三个参数为 null，否则为目标对象的类。
        checkAccess(caller, clazz,
                    Modifier.isStatic(modifiers) ? null : obj.getClass(),
                    modifiers);
    }

    // 获取MethodAccessor实例
    // 这是一个volatile字段，确保多线程访问时的可见性。
    MethodAccessor ma = methodAccessor;             // read volatile
    // 如果 methodAccessor 为空，则调用此方法获取一个新的 MethodAccessor 实例。
    // MethodAccessor 是实际执行反射调用的接口，其实现由JVM提供，可能是生成的字节码或本地代码。
    if (ma == null) {
        ma = acquireMethodAccessor();
    }

    // 使用MethodAccessor调用目标方法
    return ma.invoke(obj, args);
}

public final class Method extends Executable {
  
      private MethodAccessor acquireMethodAccessor() {
        // First check to see if one has been created yet, and take it
        // if so
        MethodAccessor tmp = null;
        if (root != null) tmp = root.getMethodAccessor();
        if (tmp != null) {
            methodAccessor = tmp;
        } else {
            // Otherwise fabricate one and propagate it up to the root
            tmp = reflectionFactory.newMethodAccessor(this);
            setMethodAccessor(tmp);
        }

        return tmp;
    }

}

public interface MethodAccessor {  
/** Matches specification in {@link java.lang.reflect.Method} */  
	public Object invoke(Object obj, Object[] args)  
throws IllegalArgumentException, InvocationTargetException;  
}

/** Used only for the first few invocations of a Method; afterward,
    switches to bytecode-based implementation */

class NativeMethodAccessorImpl extends MethodAccessorImpl {
    private final Method method;
    private DelegatingMethodAccessorImpl parent;
    private int numInvocations;

    NativeMethodAccessorImpl(Method method) {
        this.method = method;
    }

    public Object invoke(Object obj, Object[] args)
        throws IllegalArgumentException, InvocationTargetException
    {
        // We can't inflate methods belonging to vm-anonymous classes because
        // that kind of class can't be referred to by name, hence can't be
        // found from the generated bytecode.
        if (++numInvocations > ReflectionFactory.inflationThreshold()
                && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
            MethodAccessorImpl acc = (MethodAccessorImpl)
                new MethodAccessorGenerator().
                    generateMethod(method.getDeclaringClass(),
                                   method.getName(),
                                   method.getParameterTypes(),
                                   method.getReturnType(),
                                   method.getExceptionTypes(),
                                   method.getModifiers());
            parent.setDelegate(acc);
        }

        return invoke0(method, obj, args);
    }

    void setParent(DelegatingMethodAccessorImpl parent) {
        this.parent = parent;
    }

    private static native Object invoke0(Method m, Object obj, Object[] args);
}

abstract class MethodAccessorImpl extends MagicAccessorImpl  
implements MethodAccessor {  
/** Matches specification in {@link java.lang.reflect.Method} */  
	public abstract Object invoke(Object obj, Object[] args)  
throws IllegalArgumentException, InvocationTargetException;  
}

class DelegatingMethodAccessorImpl extends MethodAccessorImpl {
    private MethodAccessorImpl delegate;

    DelegatingMethodAccessorImpl(MethodAccessorImpl delegate) {
        setDelegate(delegate);
    }

    public Object invoke(Object obj, Object[] args)
        throws IllegalArgumentException, InvocationTargetException
    {
        return delegate.invoke(obj, args);
    }

    void setDelegate(MethodAccessorImpl delegate) {
        this.delegate = delegate;
    }
}