参考资料：

1. java反射机制深入理解剖析 https://www.w3cschool.cn/java/java-reflex.html
2. https://dunwu.github.io/javacore/basics/java-reflection.html

   反射简介：

   主要是指程序可以访问，检测和修改本身状态或者行为的一种能力，通过反射可以调用私有方法和私有属性，大部分框架也都是运用反射原理的。java通常是先有类再有对象，有对象就可以调用方法或者属性，java中的反射其实是通过Class对象来调用类里面的方法。
   一个类有多个组成部分，例如：成员变量、方法、构造方法等，反射就是加载类,并解剖出类的各个组成部分。

反射机制主要提供以下功能：

①在运行时判断任意一个对象所属的类；

②在运行时构造任意一个类的对象；

③在运行时判断任意一个类所具有的成员变量和方法；

④在运行时调用任意一个对象的方法；

⑤生成动态代理。

类加载器的左右

package com.lagou.dachang;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Date;
import org.junit.Test;
/**
 * @author yumingxing
 * @version 1.0
 * @date 2022/4/18 23:30
 **/
public class TestReflect implements Serializable  {
  private String value;
  private Date date;
  /**
   * 通过对象获得完整的包名和类名
   */
  @Test
  public void getNameBy(){
    TestReflect testReflect = new TestReflect();
    System.out.println("testReflect.getClass().getName() = " + testReflect.getClass().getName());
  }
  /**
   * 实例化Class类对象
   */
  @Test
  public void instantiateObject(){
    //方式一
    try {
      Class<?> class1 = Class.forName("com.lagou.dachang.TestReflect");
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
    //方式二
    Class<? extends TestReflect> class2 = new TestReflect().getClass();
    //方式三
    Class<TestReflect> class3 = TestReflect.class;
  }
  /**
   * 获取一个对象的父类与实现的接口
   */
  @Test
  public void getSupper() throws ClassNotFoundException {
    Class<?> clazz = Class.forName("com.lagou.dachang.TestReflect");
    Class<?> superclass = clazz.getSuperclass();
    System.out.println("clazz的父类为:" + superclass.getName());
    Class<?>[] interfaces = clazz.getInterfaces();
    System.out.println("interfaces:");
    for (Class<?> anInterface : interfaces) {
      System.out.println(anInterface);
    }
  }
  /**
   * 通过反射实例化一个对象
   */
  @Test
  public void createInstance()
      throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {
    Class<?> clazz = Class.forName("com.lagou.dachang.User");
    User user = (User) clazz.newInstance();
    user.setAge(18);
    user.setName("john");
    Constructor<?>[] constructors = clazz.getConstructors();
    for (Constructor<?> constructor : constructors) {
      System.out.println("constructor = " + constructor.getName());
      Class<?>[] parameterTypes = constructor.getParameterTypes();
      for (Class<?> parameterType : parameterTypes) {
        System.out.println("parameterType = " + parameterType.getName());
      }
    }
    User marry = (User) constructors[0].newInstance("marry");
    System.out.println("marry = " + marry);
    User helen = (User) constructors[1].newInstance(20, "helen");
    System.out.println("helen = " + helen);
  }
  /**
   * 通过反射获取某个类的全部属性
   */
  @Test
  public void getFields() throws ClassNotFoundException {
    Class<?> clazz = Class.forName("com.lagou.dachang.TestReflect");
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
      System.out.println("field.getModifiers() = " + Modifier.toString(field.getModifiers()));
      Class<?> type = field.getType();
      System.out.println(type.getName() + ":" + field.getName());
    }
  }
  /**
   * 获取某个类的全部方法
   */
  @Test
  public void getMethods() throws ClassNotFoundException{
    Class<?> clazz = Class.forName("com.lagou.dachang.TestReflect");
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
      System.out.println("method = " + method.getName());
      Class<?> returnType = method.getReturnType();
      System.out.println("returnType = " + returnType);
      System.out.println(
          "Modifier.toString(method.getModifiers()) = " + Modifier.toString(method.getModifiers()));
      Class<?>[] parameterTypes = method.getParameterTypes();
      for (Class<?> parameterType : parameterTypes) {
        System.out.println("parameterType.getName() = " + parameterType.getName());
      }
      Class<?>[] exceptionTypes = method.getExceptionTypes();
      for (Class<?> exceptionType : exceptionTypes) {
        System.out.println(exceptionType.getName());
      }
    }
  }
  /**
   * 通过反射调用方法
   */
  @Test
  public void callMethod() throws Exception{
    Class<?> clazz = Class.forName("com.lagou.dachang.TestReflect");
    Method method = clazz.getMethod("reflect1");
    method.invoke(clazz.newInstance());
    method = clazz.getMethod("reflect2", int.class, String.class);
    method.invoke(clazz.newInstance(),20,"张三");
  }
  /**
   * 通过反射操作某个类的属性
   */
  @Test
  public void changeField() throws  Exception{
    Class<?> clazz = Class.forName("com.lagou.dachang.TestReflect");
    TestReflect testReflect = (TestReflect) clazz.newInstance();
    Field name = clazz.getDeclaredField("value");
    name.setAccessible(true);
    name.set(testReflect,"java反射机制");
    System.out.println(testReflect.getValue());
  }
  public void reflect1() {
    System.out.println("Java 反射机制 - 调用某个类的方法1.");
  }
  public void reflect2(int age, String name) {
    System.out.println("Java 反射机制 - 调用某个类的方法2.");
    System.out.println("age -> " + age + ". name -> " + name);
  }
  public String getValue() {
    return value;
  }
  public void setValue(String value) {
    this.value = value;
  }
  public Date getDate() {
    return date;
  }
  public void setDate(Date date) {
    this.date = date;
  }
}
class User{
  private int age;
  private String name;
  public User() {
  }
  public User(int age, String name) {
    this.age = age;
    this.name = name;
  }
  public User(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "User{" +
        "age=" + age +
        ", name='" + name + '\'' +
        '}';
  }
}