1
2

User user = new User(); 
user.setName("张三");

1

Class.forName("com.example.User").getMethod("setName").invoke(obj, "张三");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

import java.lang.reflect.Method;

public class ReflectOptimization {
    // 优化前：每次调用都重新获取Method对象
    public static void noCache() throws Exception {
        for (int i = 0; i < 100000; i++) {
            User user = new User();
            Method method = User.class.getMethod("setName", String.class);
            method.invoke(user, "张三");
        }
    }

    // 优化后：缓存Method对象，复用
    private static final Method SET_NAME_METHOD;
    static {
        try {
            SET_NAME_METHOD = User.class.getMethod("setName", String.class);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    public static void withCache() throws Exception {
        for (int i = 0; i < 100000; i++) {
            User user = new User();
            SET_NAME_METHOD.invoke(user, "张三");
        }
    }

    // 性能测试
    public static void main(String[] args) throws Exception {
        long start1 = System.currentTimeMillis();
        noCache();
        System.out.println("无缓存耗时：" + (System.currentTimeMillis() - start1) + "ms");

        long start2 = System.currentTimeMillis();
        withCache();
        System.out.println("有缓存耗时：" + (System.currentTimeMillis() - start2) + "ms");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public class MethodHandleDemo {
    public static void main(String[] args) throws Throwable {
        // 1. 获取MethodHandles.Lookup
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        // 2. 定义方法类型：返回值void，参数String
        MethodType methodType = MethodType.methodType(void.class, String.class);
        // 3. 查找方法
        MethodHandle setNameHandle = lookup.findVirtual(User.class, "setName", methodType);

        // 4. 调用方法
        User user = new User();
        setNameHandle.invoke(user, "李四");
        System.out.println(user.getName()); // 输出：李四
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import java.lang.reflect.Field;

public class SetAccessibleDemo {
    public static void main(String[] args) throws Exception {
        User user = new User();
        // 获取private属性name
        Field nameField = User.class.getDeclaredField("name");

        // ❌ 不关闭访问检查，直接操作会抛异常：IllegalAccessException
        // nameField.set(user, "张三");

        // ✅ 关闭访问检查
        nameField.setAccessible(true);
        nameField.set(user, "张三");
        System.out.println(nameField.get(user)); // 输出：张三
    }
}

1
2
3
4

Class<?> c1 = Class.forName("com.example.User");
Class<?> c2 = User.class;
Class<?> c3 = new User().getClass();
System.out.println(c1 == c2 && c2 == c3); // true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package com.example;

public class User {
    private String name;
    private int age;
    public String gender;

    public User() {}
    private User(String name, int age) { this.name = name; this.age = age; }

    public void sayHello() { System.out.println("Hello, " + name); }
    private String getSecret() { return "I love Java"; }

    // getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.lang.reflect.Constructor;

public class ClassCreateObjectDemo {
    public static void main(String[] args) throws Exception {
        Class<User> userClass = User.class;

        // 1. 推荐方式：通过public无参构造创建对象
        Constructor<User> noArgConstructor = userClass.getConstructor();
        User user1 = noArgConstructor.newInstance();
        user1.setName("张三");
        System.out.println("无参构造创建：" + user1.getName());

        // 2. 通过private有参构造创建对象（暴力反射）
        Constructor<User> privateConstructor = userClass.getDeclaredConstructor(String.class, int.class);
        privateConstructor.setAccessible(true); // 关闭访问检查
        User user2 = privateConstructor.newInstance("李四", 20);
        System.out.println("私有构造创建：" + user2.getName());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.lang.reflect.Constructor;

public class ClassGetConstructorsDemo {
    public static void main(String[] args) {
        Class<User> userClass = User.class;

        System.out.println("所有public构造器：");
        Constructor<?>[] publicConstructors = userClass.getConstructors();
        for (Constructor<?> constructor : publicConstructors) {
            System.out.println("- " + constructor);
        }

        System.out.println("\n所有构造器（包括私有）：");
        Constructor<?>[] allConstructors = userClass.getDeclaredConstructors();
        for (Constructor<?> constructor : allConstructors) {
            System.out.println("- " + constructor);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import java.lang.reflect.Field;

public class ClassGetFieldsDemo {
    public static void main(String[] args) throws Exception {
        Class<User> userClass = User.class;
        User user = userClass.getConstructor().newInstance();

        // 获取并操作private属性
        Field nameField = userClass.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(user, "王五");
        System.out.println("name属性值：" + nameField.get(user));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import java.lang.reflect.Method;

public class ClassGetMethodsDemo {
    public static void main(String[] args) throws Exception {
        Class<User> userClass = User.class;
        User user = userClass.getDeclaredConstructor(String.class, int.class).newInstance("赵六", 22);
        user.setAccessible(true);

        // 调用public方法
        Method sayHelloMethod = userClass.getMethod("sayHello");
        sayHelloMethod.invoke(user); // 输出：Hello, 赵六

        // 调用private方法
        Method getSecretMethod = userClass.getDeclaredMethod("getSecret");
        getSecretMethod.setAccessible(true);
        String secret = (String) getSecretMethod.invoke(user);
        System.out.println("私有方法返回值：" + secret);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class ClassInfoDemo {
    public static void main(String[] args) {
        Class<User> userClass = User.class;

        System.out.println("全类名：" + userClass.getName()); // com.example.User
        System.out.println("简单类名：" + userClass.getSimpleName()); // User
        System.out.println("包名：" + userClass.getPackage().getName()); // com.example
        System.out.println("父类：" + userClass.getSuperclass().getName()); // java.lang.Object
        System.out.println("是否是接口：" + userClass.isInterface()); // false
        System.out.println("是否是数组：" + userClass.isArray()); // false
    }
}

1
2
3
4
5
6
7
8
9

import java.lang.reflect.Constructor;

Class<User> userClass = User.class;
// ✅ 调用者是 Class 对象 → 执行 Class.newInstance()
User user1 = userClass.newInstance();

// ✅ 调用者是 Constructor 对象 → 执行 Constructor.newInstance()
Constructor<User> constructor = userClass.getConstructor();
User user2 = constructor.newInstance();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class ClassSingletonDemo {
    public static void main(String[] args) {
        // 验证普通类
        Class<?> c1 = User.class;
        Class<?> c2 = new User().getClass();
        System.out.println(c1 == c2); // true

        // 验证数组
        Class<?> arr1 = int[].class;
        Class<?> arr2 = new int[10].getClass();
        System.out.println(arr1 == arr2); // true

        // 验证基本数据类型
        System.out.println(int.class == int.class); // true
    }
}

class User {}

1

Class<?> clazz = Class.forName("包名.类名");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class ForNameDemo {
    public static void main(String[] args) {
        try {
            // 1. 加载普通类
            Class<?> userClass = Class.forName("com.example.User");
            System.out.println("加载User类成功：" + userClass.getName());

            // 2. JDBC 加载驱动（经典应用）
            Class.forName("com.mysql.cj.jdbc.Driver");
            System.out.println("MySQL驱动加载成功");

        } catch (ClassNotFoundException e) {
            System.err.println("类不存在：" + e.getMessage());
        }
    }
}

// 验证静态代码块执行
class User {
    static {
        System.out.println("User类的静态代码块执行了");
    }
}

1
2
3

Class<User> userClass = User.class;
Class<Integer> intClass = int.class;
Class<List> listClass = List.class;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class ClassLiteralDemo {
    public static void main(String[] args) {
        // 1. 普通类
        Class<User> userClass = User.class;
        System.out.println("User类：" + userClass.getSimpleName());

        // 2. 基本数据类型（只能用这种方式）
        Class<Integer> intClass = int.class;
        System.out.println("int类型：" + intClass.getName());

        // 3. 接口
        Class<Runnable> runnableClass = Runnable.class;
        System.out.println("Runnable接口：" + runnableClass.getName());

        // 4. 数组
        Class<String[]> stringArrayClass = String[].class;
        System.out.println("String数组：" + stringArrayClass.getName());

        // 5. void
        Class<Void> voidClass = void.class;
        System.out.println("void类型：" + voidClass.getName());
    }
}

1
2

Object obj = new User(); 
Class<?> clazz = obj.getClass();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class GetClassDemo {
    public static void main(String[] args) {
        // 声明类型是 Animal，实际类型是 Dog
        Animal animal = new Dog();
        
        // getClass() 返回实际运行时的类 Dog.class
        Class<?> clazz = animal.getClass();
        System.out.println("对象的实际类型：" + clazz.getName()); // com.example.Dog

        // 对比：类名.class 返回声明的类型 Animal.class
        System.out.println("声明的类型：" + Animal.class.getName()); 
        // com.example.Animal
    }
}

class Animal {}
class Dog extends Animal {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class PrimitiveVsWrapperDemo {
    public static void main(String[] args) {
        // 基本数据类型
        Class<Integer> intClass = int.class;
        // 包装类
        Class<Integer> integerClass = Integer.class;

        System.out.println(intClass == integerClass); // false

        // 包装类的 TYPE 常量指向对应的基本类型 Class 对象
        System.out.println(intClass == Integer.TYPE); // true
        System.out.println(boolean.class == Boolean.TYPE); // true
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class ArrayClassDemo {
    public static void main(String[] args) {
        int[] arr1 = new int[10];
        int[] arr2 = new int[100];
        int[][] arr3 = new int[5][5];

        System.out.println(arr1.getClass() == arr2.getClass()); // true（同类型同维度）
        System.out.println(arr1.getClass() == arr3.getClass()); // false（不同维度）
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class AnonymousClassDemo {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {}
        };

        System.out.println(runnable.getClass().getName()); 
        // 输出：com.example.AnonymousClassDemo$1
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class ClassLoadTimingDemo {
    public static void main(String[] args) {
        // 被动引用1：通过子类引用父类的静态变量
        // 只会输出"父类初始化"，不会输出"子类初始化"
        System.out.println(Child.parentStaticVar);

        // 被动引用2：定义类的数组
        // 不会输出任何初始化信息
        User[] users = new User[10];

        // 被动引用3：引用类的常量
        // 不会输出"常量类初始化"
        System.out.println(ConstantClass.CONSTANT);

        // 主动引用：创建对象
        // 会输出"User类初始化"
        User user = new User();
    }
}

class Parent {
    public static int parentStaticVar = 100;
    static {
        System.out.println("父类初始化");
    }
}

class Child extends Parent {
    static {
        System.out.println("子类初始化");
    }
}

class User {
    static {
        System.out.println("User类初始化");
    }
}

class ConstantClass {
    public static final String CONSTANT = "hello";
    static {
        System.out.println("常量类初始化");
    }
}

1
2
3

类加载流程：
加载 → 验证 → 准备 → 解析 → 初始化
└────────── 连接阶段 ─┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class PreparePhaseDemo {
    // 准备阶段：分配内存，设置默认值0
    // 初始化阶段：赋值为100
    public static int a = 100;

    // 准备阶段：直接赋值为200（final修饰的静态常量）
    public static final int b = 200;

    public static void main(String[] args) {
        System.out.println(a); // 100
        System.out.println(b); // 200
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class InitializationOrderDemo {
    public static void main(String[] args) {
        new Son();
    }
}

class Father {
    static {
        System.out.println("父类静态代码块");
    }

    public Father() {
        System.out.println("父类构造方法");
    }
}

class Son extends Father {
    static {
        System.out.println("子类静态代码块");
    }

    public Son() {
        System.out.println("子类构造方法");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 父类
class Base {
    public String basePublicField;
    private int basePrivateField;

    public void basePublicMethod() {}
    private void basePrivateMethod() {}
}

// 子类（演示用）
@Deprecated
public class Student extends Base {
    // 不同修饰符的属性
    public String name;
    protected int age;
    private String address;
    public static final String SCHOOL = "清华大学";

    // 不同修饰符的构造器
    public Student() {}
    public Student(String name) { this.name = name; }
    private Student(String name, int age) { this.name = name; this.age = age; }

    // 不同修饰符的方法
    public void study() {}
    protected void eat() {}
    private void sleep() {}
    public static void run() {}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionUtilsDemo {
    public static void main(String[] args) throws Exception {
        Class<Student> studentClass = Student.class;

        // 1. getName: 获取全类名（包名+类名）
        System.out.println("1. 全类名：" + studentClass.getName());
        // 输出：com.hspedu.reflection.Student

        // 2. getSimpleName: 获取简单类名
        System.out.println("\n2. 简单类名：" + studentClass.getSimpleName());
        // 输出：Student

        // 3. getFields: 获取所有public修饰的属性，包含本类以及父类的
        // 不能访问私有成员
        System.out.println("\n3. 所有public属性（含父类）：");
        Field[] publicFields = studentClass.getFields();
        for (Field field : publicFields) {
            System.out.println("- " + field.getName());
        }
        // 输出：name, SCHOOL, basePublicField

        // 4. getDeclaredFields: 获取本类中所有属性（不包含父类）
        // 配合 setAccessible(true)能访问私有成员
        System.out.println("\n4. 本类所有属性（不含父类）：");
        Field[] allFields = studentClass.getDeclaredFields();
        for (Field field : allFields) {
            System.out.println("- " + field.getName());
        }
        // 输出：name, age, address, SCHOOL

        // 5. getMethods: 获取所有public修饰的方法，包含本类以及父类的
        System.out.println("\n5. 所有public方法（含父类）：");
        Method[] publicMethods = studentClass.getMethods();
        for (Method method : publicMethods) {
            System.out.println("- " + method.getName());
        }
        // 输出：study, run, basePublicMethod, wait, equals, toString, hashCode...（Object类的方法）

        // 6. getDeclaredMethods: 获取本类中所有方法（不包含父类）
        System.out.println("\n6. 本类所有方法（不含父类）：");
        Method[] allMethods = studentClass.getDeclaredMethods();
        for (Method method : allMethods) {
            System.out.println("- " + method.getName());
        }
        // 输出：study, eat, sleep, run

        // 7. getConstructors: 获取本类所有public修饰的构造器
        System.out.println("\n7. 所有public构造器：");
        Constructor<?>[] publicConstructors = studentClass.getConstructors();
        for (Constructor<?> constructor : publicConstructors) {
            System.out.println("- " + constructor.getName());
        }
        // 输出：com.hspedu.reflection.Student（无参）、com.hspedu.reflection.Student（一个参数）

        // 8. getDeclaredConstructors: 获取本类中所有构造器
        System.out.println("\n8. 本类所有构造器：");
        Constructor<?>[] allConstructors = studentClass.getDeclaredConstructors();
        for (Constructor<?> constructor : allConstructors) {
            System.out.println("- " + constructor.getName());
        }
        // 输出：无参、一个参数、两个参数（私有）

        // 9. getPackage: 以Package形式返回包信息
        System.out.println("\n9. 包信息：" + studentClass.getPackage().getName());
        // 输出：com.hspedu.reflection

        // 10. getSuperClass: 以Class形式返回父类信息
        System.out.println("\n10. 父类信息：" + studentClass.getSuperclass().getName());
        // 输出：com.hspedu.reflection.Base

        // 11. getInterfaces: 以Class[]形式返回接口信息
        System.out.println("\n11. 实现的接口：");
        Class<?>[] interfaces = studentClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("- " + anInterface.getName());
        }
        // 输出：无（Student类没有实现接口）

        // 12. getAnnotations: 以Annotation[]形式返回注解信息
        System.out.println("\n12. 类上的注解：");
        Annotation[] annotations = studentClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("- " + annotation.annotationType().getName());
        }
        // 输出：java.lang.Deprecated
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class FieldDemo {
    public static void main(String[] args) {
        Class<Student> studentClass = Student.class;
        Field[] allFields = studentClass.getDeclaredFields();

        for (Field field : allFields) {
            System.out.println("属性名：" + field.getName());
            
            // 1. getModifiers: 以int形式返回修饰符
            int modifiers = field.getModifiers();
            // 将int值转换为对应的修饰符字符串
            String modifierStr = Modifier.toString(modifiers);
            System.out.println("修饰符：" + modifierStr + "（int值：" + modifiers + "）");
            
            // 2. getType: 以Class形式返回属性类型
            Class<?> type = field.getType();
            System.out.println("属性类型：" + type.getName());
            System.out.println("------------------------");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class MethodDemo {
    public static void main(String[] args) {
        Class<Student> studentClass = Student.class;
        Method[] allMethods = studentClass.getDeclaredMethods();

        for (Method method : allMethods) {
            System.out.println("方法名：" + method.getName());
            
            // 1. getModifiers: 以int形式返回修饰符
            int modifiers = method.getModifiers();
            String modifierStr = Modifier.toString(modifiers);
            System.out.println("修饰符：" + modifierStr);
            
            // 2. getReturnType: 以Class形式获取返回类型
            Class<?> returnType = method.getReturnType();
            System.out.println("返回类型：" + returnType.getName());
            
            // 3. getParameterTypes: 以Class[]返回参数类型数组
            Class<?>[] parameterTypes = method.getParameterTypes();
            System.out.print("参数类型：");
            for (Class<?> parameterType : parameterTypes) {
                System.out.print(parameterType.getName() + " ");
            }
            System.out.println("\n------------------------");
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;

public class ConstructorDemo {
    public static void main(String[] args) {
        Class<Student> studentClass = Student.class;
        Constructor<?>[] allConstructors = studentClass.getDeclaredConstructors();

        for (Constructor<?> constructor : allConstructors) {
            System.out.println("构造器名：" + constructor.getName());
            
            // 1. getModifiers: 以int形式返回修饰符
            int modifiers = constructor.getModifiers();
            String modifierStr = Modifier.toString(modifiers);
            System.out.println("修饰符：" + modifierStr);
            
            // 2. getParameterTypes: 以Class[]返回参数类型数组
            Class<?>[] parameterTypes = constructor.getParameterTypes();
            System.out.print("参数类型：");
            for (Class<?> parameterType : parameterTypes) {
                System.out.print(parameterType.getName() + " ");
            }
            System.out.println("\n------------------------");
        }
    }
}