docs: 更新20260812课堂笔记，同步代码变更——新增反射Constructor构造方法(Demo06：getConstructors/getConstructor获取public构造、getDeclaredConstructors/getDeclaredConstructor获取含private构造、setAccessible(true)暴力反射访问私有构造方法、newInstance()反射创建对象+instanceof判断+强转调用方法、反射最核心用途：框架根据配置类名获取构造方法创建对象Spring IOC)章节，Student新增3个构造方法(public无参/private 2参/public 4参)，更新内容概览/目录/知识点总结/随堂练习/拓展阅读，同步更新README总览两张表

授课代码/c260812/src/course/Demo06.java

@@ -0,0 +1,66 @@
+package course;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo06
+ * @description 反射-Constructor构造方法
+ * @create 2026/8/12
+ */
+public class Demo06 {
+    /*
+        当我们拿到了Class对象后，就可以通过这个对象获取构造方法，并且用构造方法创建对象，这也是反射在框架中最核心的用途。
+        Spring 框架 IOC 就是根据配置文件提供的类名，通过反射获取构造方法创建对象。
+        public Constructor<?>[] getConstructors()   获取所有public构造方法对象数组
+        public Constructor<T> getConstructor(Class<?>... parameterTypes) 返回指定的单个public构造方法对象
+        public Constructor<?>[] getDeclaredConstructors() 获取所有构造方法对象数组（包括private）
+        public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回指定的单个构造方法对象（包括private）
+
+        包含 Declared 的就是获取所有的，包括私有化的。不含 Declared 的就是获取public修饰的
+        Constructor对象的方法：
+        setAccessible(true) 允许访问私有构造方法
+
+
+
+     */
+    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
+        // 根据 Student 类的全类名，获取Student的Class对象
+        Class<?> studentClass = Class.forName("course.Student");
+        // 根据studentClass对象获取Student的构造方法--获取所有public修饰的构造方法
+        Constructor<?>[] constructors = studentClass.getConstructors();
+        System.out.println(Arrays.toString(constructors));
+        //获取Student的public修饰的无参构造方法
+        Constructor<?> constructor = studentClass.getConstructor();
+        //通过获取到的无参构造方法的对象，创建Student的对象
+        Object o = constructor.newInstance();
+        //判断这个o对象是不是Student类型
+        System.out.println("这个对象是Student类型吗？"+(o instanceof Student));
+        //强转
+        Student s=(Student) o;
+        //调用方法
+        s.study();
+        //---这种强行利用反射获取类的私有成员并操作私有成员的情况--暴力反射
+        //根据studentClass对象获取Student的构造方法--包括private的
+        Constructor<?>[] declaredConstructors = studentClass.getDeclaredConstructors();
+        System.out.println("构造方法个数："+declaredConstructors.length);
+        //获取Student的private修饰的有参数参构造方法
+        Constructor<?> declaredConstructor = studentClass.getDeclaredConstructor( String.class,Integer.class);
+
+        //允许访问私有化成员
+        declaredConstructor.setAccessible(true);
+
+        //通过对象创建Student的对象，调用的是Student私有的有参构造方法
+        Object o1 = declaredConstructor.newInstance("张三", 1001);
+
+        if (o1 instanceof Student){
+            Student s1=(Student) o1;
+            s1.study();
+        }
+    }
+
+
+}

授课代码/c260812/src/course/Student.java

@@ -13,6 +13,21 @@ public class Student{
     private Integer age;
     private String gender;
 
+    public Student() {
+    }
+
+    private Student(String name, Integer id) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public Student(Integer id, String name, Integer age, String gender) {
+        this.id = id;
+        this.name = name;
+        this.age = age;
+        this.gender = gender;
+    }
+
     public void study(){
         System.out.println(name+"在学习.....");
     }

课堂笔记/01-JavaSE基础-笔记/20260812-笔记.md

@@ -4,6 +4,7 @@
 - **项目**：`c260812`
 - **包路径**：`course`
 - **作者**：WanJL
+- **内容概览**：类的加载机制（类加载 6 时机 / 加载过程 3 大步 5 小步 / Demo01 静态代码块→代码块→构造方法执行顺序）+ 类加载器与双亲委派（Demo02 三种类加载器 / Demo03 双亲委派模型 + Properties 加载配置文件）+ 反射（Demo04 反射概念 / Demo05 获取 Class 对象三种方式 / Demo06 反射-Constructor 构造方法：获取构造方法 + 暴力反射访问私有构造方法）
 
 ---
 
@@ -19,9 +20,10 @@
 8. [用类加载器加载资源配置文件：getResourceAsStream + Properties（Demo03 + prop.properties）](#8-用类加载器加载资源配置文件getresourceasstream--propertiesdemo03--propproperties)
 9. [反射机制：运行时动态获取类的信息（Demo04）](#9-反射机制运行时动态获取类的信息demo04)
 10. [获取 Class 对象的三种方式（Demo05 + Student）](#10-获取-class-对象的三种方式demo05--student)
-11. [知识点全景总结](#11-知识点全景总结)
-12. [随堂练习要点](#12-随堂练习要点)
-13. [拓展阅读](#13-拓展阅读)
+11. [反射 Constructor 构造方法：获取与暴力反射（Demo06 + Student）](#11-反射-constructor-构造方法获取与暴力反射demo06--student)
+12. [知识点全景总结](#12-知识点全景总结)
+13. [随堂练习要点](#13-随堂练习要点)
+14. [拓展阅读](#14-拓展阅读)
 
 ---
 
@@ -874,7 +876,173 @@ class Animal{
 
 ---
 
-## 11. 知识点全景总结
+## 11. 反射 Constructor 构造方法：获取与暴力反射（Demo06 + Student）
+
+### 概念 —— 拿到 Class 对象后，反射最核心的用途：获取构造方法创建对象
+
+当我们拿到了 Class 对象后，就可以通过这个对象**获取构造方法，并且用构造方法创建对象**——这也是**反射在框架中最核心的用途**。例如 **Spring 框架的 IOC**，就是根据配置文件提供的类名，通过反射获取构造方法创建对象。
+
+```java
+// 来源：course/Demo06.java（类注释）
+/*
+    当我们拿到了Class对象后，就可以通过这个对象获取构造方法，并且用构造方法创建对象，这也是反射在框架中最核心的用途。
+    Spring 框架 IOC 就是根据配置文件提供的类名，通过反射获取构造方法创建对象。
+    public Constructor<?>[] getConstructors()   获取所有public构造方法对象数组
+    public Constructor<T> getConstructor(Class<?>... parameterTypes) 返回指定的单个public构造方法对象
+    public Constructor<?>[] getDeclaredConstructors() 获取所有构造方法对象数组（包括private）
+    public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回指定的单个构造方法对象（包括private）
+
+    包含 Declared 的就是获取所有的，包括私有化的。不含 Declared 的就是获取public修饰的
+    Constructor对象的方法：
+    setAccessible(true) 允许访问私有构造方法
+*/
+```
+
+### 获取构造方法的 4 个 API —— Declared 决定能否拿到私有成员
+
+| 方法 | 作用 | 能否获取 private 构造方法 |
+|------|------|---------------------------|
+| `getConstructors()` | 获取**所有 public 构造方法**对象数组 | ❌ 只能拿到 public |
+| `getConstructor(Class<?>... parameterTypes)` | 返回**指定的单个 public 构造方法**对象 | ❌ 只能拿到 public |
+| `getDeclaredConstructors()` | 获取**所有构造方法**对象数组（**包括 private**） | ✅ 含 private |
+| `getDeclaredConstructor(Class<?>... parameterTypes)` | 返回**指定的单个构造方法**对象（**包括 private**） | ✅ 含 private |
+
+> **要点**：
+> - **记忆口诀**：**包含 `Declared` 的就是获取所有的（包括私有化的）；不含 `Declared` 的就是获取 public 修饰的**
+> - **参数写法**：`parameterTypes` 传构造方法的**参数类型 Class 数组/可变参数**——如 `getDeclaredConstructor(String.class, Integer.class)` 表示获取参数为 `(String, Integer)` 的构造方法
+> - **Constructor 对象的方法**：`setAccessible(true)` **允许访问私有构造方法**（暴力反射的关键一步）
+
+### 暴力反射 —— setAccessible(true) 绕过 private 限制
+
+通过 `getDeclaredConstructors()` 可以拿到**私有的构造方法**，但直接 `newInstance()` 会因 private 权限报错；需要先调用 **`setAccessible(true)`** 放开访问权限，才能用私有构造方法创建对象——这种强行利用反射获取类的私有成员并操作私有成员的情况，称为**暴力反射**。
+
+```
+私有的构造方法对象（getDeclaredConstructor 获取）
+      ↓ 直接 newInstance() ❌ 抛 IllegalAccessException（私有成员不可访问）
+      ↓ setAccessible(true) 放开访问权限 ✅
+      ↓ newInstance(参数) 创建对象
+```
+
+### Demo06 代码演示：获取构造方法 + 暴力反射
+
+```java
+// 来源：course/Demo06.java
+package course;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo06
+ * @description 反射-Constructor构造方法
+ * @create 2026/8/12
+ */
+public class Demo06 {
+    /* ……（上述构造方法反射理论写在类注释中）…… */
+    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
+        // 根据 Student 类的全类名，获取Student的Class对象
+        Class<?> studentClass = Class.forName("course.Student");
+        // 根据studentClass对象获取Student的构造方法--获取所有public修饰的构造方法
+        Constructor<?>[] constructors = studentClass.getConstructors();
+        System.out.println(Arrays.toString(constructors));
+        //获取Student的public修饰的无参构造方法
+        Constructor<?> constructor = studentClass.getConstructor();
+        //通过获取到的无参构造方法的对象，创建Student的对象
+        Object o = constructor.newInstance();
+        //判断这个o对象是不是Student类型
+        System.out.println("这个对象是Student类型吗？"+(o instanceof Student));
+        //强转
+        Student s=(Student) o;
+        //调用方法
+        s.study();
+        //---这种强行利用反射获取类的私有成员并操作私有成员的情况--暴力反射
+        //根据studentClass对象获取Student的构造方法--包括private的
+        Constructor<?>[] declaredConstructors = studentClass.getDeclaredConstructors();
+        System.out.println("构造方法个数："+declaredConstructors.length);
+        //获取Student的private修饰的有参数参构造方法
+        Constructor<?> declaredConstructor = studentClass.getDeclaredConstructor( String.class,Integer.class);
+
+        //允许访问私有化成员
+        declaredConstructor.setAccessible(true);
+
+        //通过对象创建Student的对象，调用的是Student私有的有参构造方法
+        Object o1 = declaredConstructor.newInstance("张三", 1001);
+
+        if (o1 instanceof Student){
+            Student s1=(Student) o1;
+            s1.study();
+        }
+    }
+}
+```
+
+### Student 类新增构造方法（Demo06 的反射目标）
+
+```java
+// 来源：course/Student.java（本文件内新增 3 个构造方法）
+public class Student{
+    private Integer id;
+    private String name;
+    private Integer age;
+    private String gender;
+
+    public Student() {                                            // ① public 无参构造
+    }
+
+    private Student(String name, Integer id) {                    // ② private 有参构造（暴力反射目标）
+        this.name = name;
+        this.id = id;
+    }
+
+    public Student(Integer id, String name, Integer age, String gender) {  // ③ public 四参构造
+        this.id = id;
+        this.name = name;
+        this.age = age;
+        this.gender = gender;
+    }
+
+    public void study(){
+        System.out.println(name+"在学习.....");
+    }
+}
+```
+
+### 预期输出与运行要点
+
+```
+[java.lang.reflect.Constructor[..]@.., .., ..]          ← getConstructors() 打印 public 构造方法数组（有 ①②...实际 2 个 public：无参 + 四参）
+这个对象是Student类型吗？true                             ← getConstructor().newInstance() 创建的对象是 Student 类型
+null在学习.....                                          ← 无参构造 name 为 null，study() 输出 null在学习.....
+构造方法个数：3                                          ← getDeclaredConstructors() 拿到全部 3 个构造方法（含 private 的 2 参构造）
+张三在学习.....                                          ← setAccessible(true) + newInstance("张三", 1001) 调用 private 构造创建对象
+```
+
+| 代码 | 作用 | 说明 |
+|------|------|------|
+| `Class.forName("course.Student")` | 获取 Student 的 Class 对象 | 方式三（全类名，框架最常用），回顾第 10 节 |
+| `studentClass.getConstructors()` | 获取**所有 public 构造方法**数组 | 不含 private，输出数组内容（用 `Arrays.toString` 打印） |
+| `studentClass.getConstructor()` | 获取 **public 无参构造** | 参数为空表示无参构造 |
+| `constructor.newInstance()` | **用构造方法对象创建对象** | 反射创建对象的方式，等价于 `new Student()` |
+| `o instanceof Student` | 判断创建的对象类型 | 输出 true——反射创建的对象确实是 Student 类型 |
+| `(Student) o` 强转 + `s.study()` | 把 Object 强转成 Student 并调用方法 | 反射创建对象后转回具体类型调用业务方法 |
+| `studentClass.getDeclaredConstructors()` | 获取**所有构造方法**（含 private） | 拿到全部 3 个（public 无参 + private 2 参 + public 4 参） |
+| `getDeclaredConstructor(String.class, Integer.class)` | 获取指定的 **private 有参构造** | 参数类型匹配 `private Student(String, Integer)` |
+| `declaredConstructor.setAccessible(true)` | **放开私有成员的访问权限** | 暴力反射的关键一步，否则 newInstance 报权限错误 |
+| `newInstance("张三", 1001)` | 用 **private 构造**创建对象 | 成功创建 name=张三、id=1001 的 Student 对象 |
+
+> **要点**：
+> - **反射创建对象的两种路径**：`getConstructor().newInstance()`（public 构造）+ `getDeclaredConstructor().setAccessible(true).newInstance()`（private 构造）
+> - **暴力反射** = 强行利用反射获取类的私有成员并操作私有成员——`setAccessible(true)` 允许访问私有构造方法（这正是第 9 节"反射可能破坏封装性"的具体体现）
+> - **Declared 的口诀**：包含 Declared 的能拿到私有，不含的只能拿 public
+> - **方法签名抛 4 个受检异常**：`ClassNotFoundException`（forName 类名写错）/ `NoSuchMethodException`（找不到该参数类型的构造方法）/ `InstantiationException`（抽象类等无法实例化）/ `IllegalAccessException`（无访问权限）/ `InvocationTargetException`（被调方法内部抛异常）——调用反射 API 必须处理这些受检异常（main 用 throws 声明）
+> - **反射创建对象 vs new**：反射创建对象就是"运行时动态 new"，是框架（Spring IOC 等）根据配置字符串类名创建对象的底层原理
+
+---
+
+## 12. 知识点全景总结
 
 | 知识点 | 核心内容 | 来源 |
 |--------|----------|------|
@@ -917,10 +1085,16 @@ class Animal{
 | **Class 对象查看类型信息** | getName() 全类名 / getSimpleName() 简单类名 / getSuperclass() 父类 / getPackage() 包名 | course/Demo05 main |
 | **Student / Person / Animal 演示类** | Student（id/name/age/gender 私有字段 + study() 方法，反射演示目标）；Person extends Animal（静态代码块"人类的静态代码块"，验证 forName 触发静态初始化）；Animal（空父类） | course/Student.java |
 | **BootstrapClassLoader 为何是 null** | 由 C/C++ 实现、是 JVM 的一部分（不属于 Java 类），所以 Java 调用输出返回的就是 null（Demo02 注释中已标注） | course/Demo02.java |
+| **反射最核心用途：获取构造方法创建对象** | 拿到 Class 对象后可通过构造方法创建对象；Spring 框架 IOC 就是根据配置文件类名通过反射获取构造方法创建对象 | course/Demo06 注释 |
+| **获取构造方法 4 个 API** | getConstructors()（所有 public 数组）/ getConstructor(Class...)（指定 public）/ getDeclaredConstructors()（所有含 private 数组）/ getDeclaredConstructor(Class...)（指定含 private）；口诀：**含 Declared 的能拿私有，不含的只能拿 public** | course/Demo06 注释 |
+| **暴力反射与 setAccessible(true)** | 强行利用反射获取类的私有成员并操作私有成员=暴力反射；`setAccessible(true)` 允许访问私有构造方法，否则 newInstance 报权限错误 | course/Demo06 main |
+| **反射创建对象 newInstance()** | `constructor.newInstance()` 反射创建对象（等价运行时 new）；`getConstructor().newInstance()` 用 public 构造、`getDeclaredConstructor().setAccessible(true).newInstance()` 用 private 构造；`instanceof` 判断对象类型、强转后调用方法 | course/Demo06 main |
+| **Student 新增 3 个构造方法** | public 无参 / private (String name, Integer id)（暴力反射目标）/ public (Integer id, String name, Integer age, Integer gender) | course/Student.java |
+| **反射 API 的受检异常** | 反射方法签名抛多个受检异常：ClassNotFoundException / NoSuchMethodException / InstantiationException / IllegalAccessException / InvocationTargetException——必须处理（main 用 throws 声明） | course/Demo06 main |
 
 ---
 
-## 12. 随堂练习要点
+## 13. 随堂练习要点
 
 - **执行全流程复述（必做）**：把 `.java 文件 → 编译 → .class 字节码文件 → 类加载器 → 内存 → JVM 解释 → 二进制机器码 → 执行` 这条链背下来——这是理解本课所有知识点的总纲
 - **类加载 6 种时机背诵**：①创建实例对象 ②调用 static 方法 ③访问/赋值 static 变量 ④反射创建 Class 对象 ⑤初始化子类 ⑥Java.exe 运行主类——每一类都能举一个代码例子（new / Math.abs / Student.name / Class.forName / new 子类 / 运行 main 类）
@@ -962,10 +1136,18 @@ class Animal{
 - **Person extends Animal 理解**：Student.java 文件里 Person 继承 Animal 且带静态代码块——理解"一个 .java 文件可定义多个类（public 类与文件名一致，其他为包级私有类）"，为后续反射获取父类信息做铺垫
 - **反射与类加载衔接思考**：回顾第 3 节"类加载的 6 种时机"中的第 ④ 条"**反射创建 Class 对象**"——`Class.forName()` 既是获取 Class 对象的方式，也会触发类加载；本课"类加载机制 + 反射"两个主题通过 Class 对象紧密相连
 - **反射与框架串联思考**：思考 Spring 框架的 IOC 容器、MyBatis 的 Mapper 代理、JDBC 驱动加载（Class.forName("com.mysql.cj.jdbc.Driver")）——这些框架底层都是"读取配置 → Class.forName → 反射实例化/调用"的套路，后续学习框架时会反复见到
+- **获取构造方法 4 个 API 背诵（必做）**：`getConstructors()`（所有 public 数组）/ `getConstructor(Class...)`（指定 public）/ `getDeclaredConstructors()`（所有含 private 数组）/ `getDeclaredConstructor(Class...)`（指定含 private）——背口诀：**含 Declared 的能拿私有（包含所有），不含 Declared 的只能拿 public**
+- **Demo06 运行验证（必做）**：运行 `course/Demo06`，观察输出——`getConstructors()` 打印 public 构造数组、`o instanceof Student` 输出 true、无参构造创建的 name 为 null（study 输出 null在学习.....）、`getDeclaredConstructors()` 输出"构造方法个数：3"、暴力反射后"张三在学习....."——完整走一遍"获取构造方法→创建对象→强转调用方法"
+- **暴力反射实验（必做）**：把 Demo06 中 `declaredConstructor.setAccessible(true)` 一行**注释掉**再运行，观察抛 **IllegalAccessException**——直观体会"不 setAccessible(true) 无法访问 private 构造方法"、理解暴力反射为何需要放开权限
+- **getConstructor 参数实验**：尝试用 `studentClass.getConstructor(String.class, Integer.class)`（不带 Declared）获取 private 2 参构造，观察抛 **NoSuchMethodException**——体会"不含 Declared 只能拿 public"的口诀
+- **newInstance 创建对象对比**：对比"反射创建对象 `getConstructor().newInstance()`" 与 "普通 new Student()"——思考反射创建对象就是"运行时动态 new"（Spring IOC 根据配置字符串类名动态创建对象的原理）
+- **instanceof + 强转练习**：反射创建的对象是 Object 类型，用 `instanceof Student` 判断后用 `(Student) o` 强转再调用 study()——回顾 07-24 多态向下转型知识
+- **构造方法个数验证**：数一数 Student 类现有 3 个构造方法（public 无参 / private 2 参 / public 4 参），与 `getDeclaredConstructors().length` 输出"构造方法个数：3"对照——体会 Declared 拿到的是"全部构造方法"
+- **反射受检异常处理**：观察 Demo06 main 方法签名 `throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException`——理解反射 API 抛多个受检异常必须处理（回顾 07-28 异常处理：受检异常 vs 非受检异常）
 
 ---
 
-## 13. 拓展阅读
+## 14. 拓展阅读
 
 - **类加载机制的地位**：本课（类的加载机制 + 类加载器）属于 **JVM（Java 虚拟机）** 知识领域——面试高频考点，也是理解反射、动态代理、Tomcat 类隔离、Spring 框架等进阶知识的基石
 - **双亲委派模型（Parent Delegation Model）**：除了 JDK 三种内置加载器外，还可以**自定义类加载器**（继承 ClassLoader 并重写 `findClass()`）；双亲委派模型保证**核心类库只由启动类加载器加载**，避免用户自定义同名类（如自己写个 `java.lang.String`）破坏 JDK 核心类
@@ -995,4 +1177,9 @@ class Animal{
 - **反射的应用场景扩展**：反射在真实项目中的典型应用——①**动态代理**（JDK Proxy 底层基于反射的 InvocationHandler）②**Spring AOP**（切面拦截基于动态代理+反射）③**注解解析**（@Autowired/@RequestMapping 等注解通过反射读取）④**序列化框架**（Jackson/Gson 反射读写字段）⑤**开发工具**（IDEA 的代码补全、调试器的变量查看都基于反射）
 - **反射的性能优化**：反射效率低（本课提到 3~100 倍），实际框架中的优化手段——**缓存 Method/Field 对象**（避免重复 getMethod/getField）、**MethodHandle**（JDK7+ 更高效的动态调用方式）、**invokedynamic 指令**（JDK7+ 字节码层面优化，Lambda 表达式底层就是 invokedynamic）——理解这些有助于理解框架为何能"用反射但性能不差"
 - **反射与封装性/安全**：`setAccessible(true)` 可以绕过 Java 的访问控制（private 也能访问），这既是反射强大的原因，也是"破坏封装性"的根源——在某些安全要求高的场景（如模块化系统 JPMS）会限制反射的使用
-- **JDK 文档**：[`java.lang.ClassLoader`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/ClassLoader.html)（类加载器核心 API，含 getResourceAsStream）、[`java.lang.Class`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html)（Class 对象：getName/getSimpleName/getSuperclass/getPackage 等）、[`java.lang.reflect.Constructor`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html)（构造方法反射）、[`java.lang.reflect.Field`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Field.html)（字段反射）、[`java.lang.reflect.Method`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html)（方法反射）、[`java.util.Properties`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Properties.html)（配置文件解析类，父类 Hashtable）、[`Class.forName`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html#forName(java.lang.String))（反射加载类）
+- **反射三个核心成员**：本课 Demo06 已学 **Constructor（构造方法）**，反射三大核心成员还包含 **Field（字段属性）** 和 **Method（方法）**——后续课程会分别用 `getDeclaredFields()` / `getDeclaredMethods()` 获取私有字段与私有方法，套路与 Constructor 完全一致（Declared 拿私有 + setAccessible(true) 放开权限）
+- **Spring IOC 与反射**：Spring 框架的 IOC 容器**根据配置文件/注解中的类名字符串，通过反射获取构造方法创建 Bean 对象**（`Class.forName("com.xxx.UserService")` + `getDeclaredConstructor().newInstance()`）——这正是本课"反射是框架基础"论断的经典落地场景；理解反射构造方法 = 理解 Spring Bean 创建的第一步
+- **newInstance 的两种写法**：JDK9 中 `Class.newInstance()` 被标记废弃（只能调用无参构造且权限检查严格），推荐使用 **`Constructor.newInstance()`**（可以传参、可以访问 private 构造）——本课 Demo06 正是后者
+- **setAccessible(true) 的安全影响**：`setAccessible(true)` 本质是**绕过 Java 访问控制检查**（private 也能访问），在模块化系统（JPMS）中受 `--add-opens` 约束；反射框架（如 Spring）大量使用它来注入私有字段——这是"反射破坏封装性"与"框架必须用反射"的辩证关系
+- **反射创建对象的效率与优化**：本课提到反射效率低 3~100 倍，但框架实际使用中会**缓存 Constructor/Method/Field 对象**（`getDeclaredConstructor` 只调用一次，后续复用 `newInstance`）来摊薄开销——这也是框架"用了反射但性能不差"的优化手段
+- **JDK 文档**：[`java.lang.ClassLoader`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/ClassLoader.html)（类加载器核心 API，含 getResourceAsStream）、[`java.lang.Class`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html)（Class 对象：getName/getSimpleName/getSuperclass/getPackage 等）、[`java.lang.reflect.Constructor`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Constructor.html)（构造方法反射：getConstructors/getDeclaredConstructors/newInstance/setAccessible）、[`java.lang.reflect.Field`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Field.html)（字段反射）、[`java.lang.reflect.Method`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/reflect/Method.html)（方法反射）、[`java.util.Properties`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Properties.html)（配置文件解析类，父类 Hashtable）、[`Class.forName`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Class.html#forName(java.lang.String))（反射加载类）