public class ReflectionDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//     要求: 根据配置文件re.properties 指定信息，创建Cat对象并调用方法hi
/*        传统的方式 new 对象 --> 调用方法
       Cat cat = new Cat();
        cat.hi();
*/
//      1.使用Properties类，可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullPath = properties.get("classfullPath").toString();
        String methodName = properties.get("method").toString();//classfullPath=com.hsp.Cat
        System.out.println("classfullPath=" + classfullPath);//method=hi
        System.out.println("method=" + methodName);
//      2.使用反射机制解决:
//        (1)加载类，返回Class类型的对象cls
        Class cls = Class.forName(classfullPath);//class com.hsp.Cat
//        (2)通过 cls 得到你加载的类 com.hspedu.Cat的对象实例
        Object o = cls.newInstance();//com.hsp.Cat@16d3586
        System.out.println("o的运行类型=" + o.getClass());//o的运行类型=class com.hsp.Cat
//        (3)通过 cls 得到你加载的类com.hsp.Cat的 methodName"hi" 的方法对象
//        即：在反射中,可以把方法视为对象(万物皆对象)
        Method method1 = cls.getMethod(methodName);//public void com.hsp.Cat.hi()
//        (4)通过method1 调用方法:即通过方法对象来实现调用方法
        method1.invoke(o);//传统方法:对象.方法();反射机制: 方法.invoke(对象)
    } }

public class ReflectionDemo02 {
    public static void main(String[] args) throws ClassNotFoundException {
//        1.Class也是类，因此也继承Object类
//        2.Class类对象不是new出来的，而是系统创建的
//        (1)传统new对象通过 ClassLoader 类加载 
//     Cat cat = new Cat();
        /* ClassLoader 类
public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}
*/
//        (2)反射方式 仍然是通过 ClassLoader 类加载 
        /* ClassLoader 类
public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}
*/
        Class cls1 = Class.forName("com.hsp.Cat");
//3.对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
        Class cls2 = Class.forName("com.hsp.Cat");
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
    }  }

public class ReflectionDemo4 {
    public static void main(String[] args) throws ClassNotFoundException {
//        1.Class.forName
        String classAllPath = "com.hsp.Car";//通过读取配置文件获取
        Class cls1 = Class.forName(classAllPath);
        System.out.println(cls1);
//        2.类名.class,应用场景: 用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);
//        3.对象.getClass(),应用场景，有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);
//        4.通过类加载器来获取到类的Class对象
//       (1)先得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
//        (2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);
//        cls1,cls2,cls3,cls4 其实是同一个对象
        System.out.println(cls1.hashCode());//23934342
        System.out.println(cls2.hashCode());//23934342
        System.out.println(cls3.hashCode());//23934342
        System.out.println(cls4.hashCode());//23934342
//    5.基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);//int
//        6.基本数据类型对应的包装类，可以通过 .TYPE 得到 Class 类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1); //int
        System.out.println(integerClass.hashCode()); //22307196
        System.out.println(type1.hashCode()); //22307196
    } }

public class ClassLoad03 {
    public static void main(String[] args) {
//        1.加载 B 类,并生成B的class对象
//        2.连接 num = 0
//        3.初始化阶段
//        依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句,并合并
/*
        clinit() {
            System.out.println("B 静态代码块被执行");
            num = 300;//会被合并为100
            num = 100;
}
           合并: num = 100
*/
        //看看加载类的时候， 是有同步机制控制
/*
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{
//正因为有这个机制， 才能保证某个类在内存中, 只有一份 Class 对象
synchronized (getClassLoadingLock(name)) {
//...
   } }
*/
        B b = new B();//类加载
        System.out.println(B.num);//100,如果直接使用类的属性，也会导致类的加载
    } }
class B {
    static {
        System.out.println("B 静态代码块被执行了");
        num = 300;
    }
    static int num = 100;
    public B() {//构造器
        System.out.println("B() 构造器被执行了");
    } }

public class ReflecCreateInstance {
    public static void main(String[] args) throws Exception {
//        1.先获得 User 类的Class对象
        Class<?> userClass = Class.forName("com.hsp.reflection.User");
//        2.通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
//        3.通过public 的有参构造器创建实例
//        3.1 先得到对应构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
//        3.2 创建实例,并传入实参
        Object o1 = constructor.newInstance("yqd");
        System.out.println(o1);
//        4.通过非public 的有参构造器创建实例
//        4.1 得到 private 的构造对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
//        4.2 创建实例
//        暴破【暴力破解】，使用反射可以访问 private 构造器/方法/属性
        constructor1.setAccessible(true);
        Object user2 = constructor1.newInstance(100, "张无忌");
        System.out.println(user2);
    } }
class User {//User类
    private int age = 10;
    private String name = "Java";
    public User(){//无参 public
    }
    public User(String name){//public的有参构造器
        this.name = name;
    }
    private User(int age,String name){//private 有参构造器
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    } }

public class ReflecAccessProperty {
    public static void main(String[] args) throws Exception {
//      1.得到 Student 类对应的 Class 对象
        Class<?> stuClass = Class.forName("com.hsp.reflection.Student");
//        2.创建对象
        Object o = stuClass.newInstance();
        System.out.println(o.getClass());// o 的运行类型是Student
//        3.使用反射得到 age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88);//通过反射来操作属性
        System.out.println(o);
        System.out.println(age.get(o));//返回 age 属性的值
//        4.使用反射操作 name 属性
        Field name = stuClass.getDeclaredField("name");
//        对name进行暴破，可以操作 private 属性
        name.setAccessible(true);
//        name.set(o,"张三丰");
        name.set(null, "张三丰");//因为name 是 static 属性，因此 o 也可以写成null
        System.out.println(o);
        System.out.println(name.get(o));//获取属性值
        System.out.println(name.get(null));//获取属性值，要求name是static
    } }
class Student {
    public int age;
    private static String name;
    public Student() { // 构造器
    }
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    } }