反射机制学习笔记（尚硅谷康师傅2023）（一）

public class Person {
  // 属性
    private String name;
    public int age;
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private Person(String name) {
        this.name = name;
    }
    public Person() {
        System.out.println("Person()");
    }
    public void show(){
        System.out.println("你好，我是一个人");
    }
    private String showNation(String nation){
        System.out.println("我的国籍是：" + nation);
        return nation;
    }
}

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionTest {
    @Test
    public void test() throws Exception {
        // 1. 通过反射获取Person类对应的Class类型的实例对象
        // 获取的Class类型对象可以认为就是Person类
        Class personClass = Person.class;
        // 2. 通过反射(通过Person类对应的Class类型的实例对象)获取Person类的构造器
        // 获取参数为String类型和int类型的构造器
        Constructor personPublicConstructor = personClass.getConstructor(String.class, int.class);
        // 3. 通过反射(通过获取的Person类的构造器)实例化person对象
        // 实例化的对象 name = “ZS”; age = 18
        Object personObj = personPublicConstructor.newInstance("ZS", 18);
        System.out.println(personObj);
        // 4. 通过反射获取类的属性和方法
        // 获取Person类的属性
        Field personAgeField = personClass.getField("age");
        // 通过获取的Person类的属性修改person对象personObj的age属性
        personAgeField.set(personObj, 10);
        System.out.println(personObj);
        // 获取Person类的方法
        Method personShowMethod = personClass.getMethod("show");
        // 通过反射调用person对象personObj的show方法
        personShowMethod.invoke(personObj);
        System.out.println("===========================================");
        // 5. 通过反射获取Person类的私有结构，私有方法、私有属性等
        // 通过反射获取Person类的私有构造器
        Constructor personPrivateConstructor = personClass.getDeclaredConstructor(String.class);
        personPrivateConstructor.setAccessible(true); // 允许调用私有构造器
        // 使用Person类的私有构造器实例化对象
        Person personObj2 = (Person) personPrivateConstructor.newInstance("LS");
        System.out.println(personObj2);
        // 6. 通过反射获取私有属性和方法
        // 获取私有属性
        Field name = personClass.getDeclaredField("name");
        name.setAccessible(true); // 允许调用私有属性
        name.set(personObj2, "WW");
        System.out.println(personObj2);
        // 获取私有方法
        Method showNation = personClass.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true); // 允许调用私有方法
        String nation = (String) showNation.invoke(personObj2, "China");
        System.out.println(nation);
    }
}

@Test
    public void test01() throws ClassNotFoundException {
        // 方式一：
        // 通过调用运行时类的class属性获取Class实例
        // Class<T> Class带泛型
        // 获取的Class实例对象就是User类本身
        Class userClass1 = User.class;
        System.out.println(userClass1);
        // 方式二：
        // 通过运行时类的对象的getClass()方法获取Class实例
        // 不管哪个对象都可以获取到该对象是由哪个类实例化的
        User user = new User();
        Class userClass2 = user.getClass();
        System.out.println(userClass2);
        // 方式三：
        // 调用Class的静态方法，forName(String classPath)获取Class实例
        // classPath为类的全类名，全类名包含包名在内的类的完整路径
        String className = "study01.User";
        Class userClass3 = Class.forName(className); // 在内存中加载User类
        System.out.println(userClass3);
        // 方式四：
        // 使用当前类的加载器Classloader调用加载器中的loadClass(String classPath)方法获取Class实例
        // classPath为类的全类名
        // 获取系统类加载器调用加载器中的loadClass(String classPath)方法获取Class实例
        Class userClass4 = ClassLoader.getSystemClassLoader().loadClass(className); // 在内存中加载User类
        System.out.println(userClass4);
        // 不同的方法获取都是同一个Class实例对象，即都是同一个运行时类
        System.out.println(userClass1 == userClass1);
        System.out.println(userClass1 == userClass2);
        System.out.println(userClass1 == userClass3);
        System.out.println(userClass1 == userClass4);
    }

@Test
public void test01() {
    // 获取系统类加载器
    // 该方法默认获取的类加载器为系统类加载器
    // SystemClassLoader就是ApplicationClassLoader
    ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
    System.out.println(systemClassLoader);
    // 获取系统类加载器的父加载器 ExtensionClassLoader
    ClassLoader extensionClassLoader = systemClassLoader.getParent();
    System.out.println(extensionClassLoader);
    // 获取引导类记载器
    ClassLoader bootstrapClassLoader = extensionClassLoader.getParent();
    System.out.println(bootstrapClassLoader);
}

@Test
public void test02() throws ClassNotFoundException {
    // 获取User类的运行时类对象，对应的Class实例对象
    Class<User> userClass = User.class;
    // 获取加载User类的加载器
    ClassLoader classLoader = userClass.getClassLoader();
    // jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b
    // 用户自定义的类是系统类加载器加载的
    System.out.println(classLoader);
    // 将 String 这个类主动进行加载
    Class<?> stringClass = Class.forName("java.lang.String");
    // 获取加载String的类加载器
    ClassLoader stringClassClassLoader = stringClass.getClassLoader();
    // null
    // java核心库中的类有引导类加载器加载
    System.out.println(stringClassClassLoader);
}

package java.lang;
/**
 * ClassName: String
 * Package: java.lang
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-22 18:32
 * @Version 1.0
 */
public class String {
    public static void main(String[] args) {
        System.out.println("hello world...");
    }
}

@Test
public void test5() throws Exception {
    // 实例化Properties对象
    Properties pros =  new Properties();
    // 获取文件输入流对象
    // 文件默认位于当前模块下（测试方法默认从当前模块下开始读取文件）
    FileInputStream fis = new FileInputStream("jdbc.properties");
    // Properties对象加载配置文件中的内容
    pros.load(fis);
    // 读取配置文件中的user password
    String user = pros.getProperty("user");
    String password = pros.getProperty("password");
    System.out.println("user = " + user + ",password = " + password);
}

@Test
public void test6() throws Exception {
    Properties pros =  new Properties();
    // 使用ClassLoader获取系统类加载器
    ClassLoader classLoader = ClassLoader.getClassLoader();
  // 通过系统类加载器以流的方式获取资源
    // 使用该方式读取配置文件，默认的读取位置为：当前模块的src下
    InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
    // Properties对象加载配置文件中的内容
    pros.load(is);
    // 读取数据
    String user = pros.getProperty("user");
    String password = pros.getProperty("password");
    System.out.println("user = " + user + ",password = " + password);
}