void printObjectInfo(Object obj) {
    Class cls = obj.getClass();
}

// reflection
public class Main {
    public static void main(String[] args) {
        printClassInfo("".getClass());
        printClassInfo(Runnable.class);
        printClassInfo(java.time.Month.class);
        printClassInfo(String[].class);
        printClassInfo(int.class);
    }

    static void printClassInfo(Class cls) {
        System.out.println("Class name: " + cls.getName());
        System.out.println("Simple name: " + cls.getSimpleName());
        if (cls.getPackage() != null) {
            System.out.println("Package name: " + cls.getPackage().getName());
        }
        System.out.println("is interface: " + cls.isInterface());
        System.out.println("is enum: " + cls.isEnum());
        System.out.println("is array: " + cls.isArray());
        System.out.println("is primitive: " + cls.isPrimitive());
    }
}

// 获取String的Class实例:
Class cls = String.class;
// 创建一个String实例:
String s = (String) cls.newInstance();

// reflection
import java.lang.reflect.Field;
public class Main {

    public static void main(String[] args) throws Exception {
        Object p = new Person("Xiao Ming");
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        Object value = f.get(p);
        System.out.println(value); // "Xiao Ming"
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

f.setAccessible(true);

// reflection
import java.lang.reflect.Field;

public class Main {

    public static void main(String[] args) throws Exception {
        Person p = new Person("Xiao Ming");
        System.out.println(p.getName()); // "Xiao Ming"
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);
        f.set(p, "Xiao Hong");
        System.out.println(p.getName()); // "Xiao Hong"
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

String s = "Hello world";
String r = s.substring(6); // "world"

// reflection
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        // String对象:
        String s = "Hello world";
        // 获取String substring(int)方法，参数为int:
        Method m = String.class.getMethod("substring", int.class);
        // 在s对象上调用该方法并获取结果:
        String r = (String) m.invoke(s, 6);
        // 打印调用结果:
        System.out.println(r); // "world"
    }
}

// reflection
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        // 获取Integer.parseInt(String)方法，参数为String:
        Method m = Integer.class.getMethod("parseInt", String.class);
        // 调用该静态方法并获取结果:
        Integer n = (Integer) m.invoke(null, "12345");
        // 打印调用结果:
        System.out.println(n);
    }
}

// reflection
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Method m = p.getClass().getDeclaredMethod("setName", String.class);
        m.setAccessible(true);
        m.invoke(p, "Bob");
        System.out.println(p.name);
    }
}

class Person {
    String name;
    private void setName(String name) {
        this.name = name;
    }
}

// reflection
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws Exception {
        // 获取Person的hello方法:
        Method h = Person.class.getMethod("hello");
        // 对Student实例调用hello方法:
        h.invoke(new Student());
    }
}

class Person {
    public void hello() {
        System.out.println("Person:hello");
    }
}

class Student extends Person {
    public void hello() {
        System.out.println("Student:hello");
    }
}

Method m = Person.class.getMethod("hello");
m.invoke(new Student());

Person p = new Student();
p.hello();

public class Main{
  public static void main(String args[]){
    Constructor con1=Text.class.getConstructor(int.class);
    Text te=(Text)con1.newInstance(666);//注意这里这个强转是必须加的 不然会报错
    
  }
}

// 顶层父类
class Animal {
}

// 子类，继承Animal
class Dog extends Animal {
}

public class TestSuperClass {
    public static void main(String[] args) {
        // 1. 获取子类Dog的Class
        Class<?> dogCls = Dog.class;

        // 2. 调用getSuperclass() 获取直接父类Animal的Class
        Class<?> parentCls = dogCls.getSuperclass();
        System.out.println("Dog的直接父类：" + parentCls);

        // 3. 继续往上拿Animal的父类（也就是Object）
        Class<?> grandParentCls = parentCls.getSuperclass();
        System.out.println("Animal的直接父类：" + grandParentCls);

        // 4. Object再往上，结果为null
        Class<?> rootParent = grandParentCls.getSuperclass();
        System.out.println("Object的父类：" + rootParent);
    }
}

Object n = Integer.valueOf(123);
boolean isDouble = n instanceof Double; // false
boolean isInteger = n instanceof Integer; // true
boolean isNumber = n instanceof Number; // true
boolean isSerializable = n instanceof java.io.Serializable; // true

// 父类：动物
class Animal {
}

// 子类：猫，继承动物
class Cat extends Animal {
}

public class TestInstanceof {
    public static void main(String[] args) {
        // 向上转型：Object接收小猫对象（不知道具体是什么动物，先用Object兜底）
        Object pet = new Cat();

        System.out.println(pet instanceof Cat);    // true，本身就是猫
        System.out.println(pet instanceof Animal);  // true，猫继承动物
        System.out.println(pet instanceof Object);  // true，所有类都继承Object
        System.out.println(pet instanceof String);   // false 和字符串没关系
    }
}

// Integer i = ?
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
// Number n = ?
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
// Object o = ?
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
// Integer i = ?
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

/**
 * 业务接口：定义核心业务方法
 */
public interface UserService {
    // 添加用户
    void addUser();
    // 删除用户
    void deleteUser();
}

/**
 * 目标对象：专注于核心业务逻辑，无任何冗余代码
 */
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("【核心业务】执行添加用户的逻辑");
    }

    @Override
    public void deleteUser() {
        System.out.println("【核心业务】执行删除用户的逻辑");
    }
}

/**
 * 静态代理类：手动编写，和目标类一一对应
 */
public class UserServiceProxy implements UserService {
    // 持有目标对象的引用
    private UserService userService;

    // 通过构造器注入目标对象
    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void addUser() {
        // 前置增强：执行目标方法前的逻辑
        System.out.println("【日志】执行addUser方法前，请求参数校验通过");
        // 调用目标对象的核心方法
        userService.addUser();
        // 后置增强：执行目标方法后的逻辑
        System.out.println("【日志】执行addUser方法后，操作成功，耗时10ms");
    }

    @Override
    public void deleteUser() {
        System.out.println("【日志】执行deleteUser方法前，请求参数校验通过");
        userService.deleteUser();
        System.out.println("【日志】执行deleteUser方法后，操作成功，耗时8ms");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        // 1. 创建目标对象
        UserService userService = new UserServiceImpl();
        // 2. 创建代理对象，传入目标对象
        UserService proxy = new UserServiceProxy(userService);
        // 3. 调用代理对象的方法，底层会调用目标对象的方法并执行增强逻辑
        proxy.addUser();
        System.out.println("------------------------");
        proxy.deleteUser();
    }
}

UserService userService = new UserServiceImpl();