package com.curtis.reflect;

import java.lang.reflect.Method;

public class ClassMessage {

    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        p1.setIdCard("1000");
        p1.setName("Curtis");
        p1.setAge(27);
        // 1、System.out.println(p1);

        // 2、p1.eat();

        Class c1 = Person.class;
        Class c2 = p1.getClass();
        Class c3 = Class.forName("com.curtis.reflect.Person");

        // 3、System.out.println(c1==c2);// true
        // 4、System.out.println(c2==c3);// true

        // 5、System.out.println(c1.getName()); // 全类名 com.curtis.reflect.Person
        // 6、System.out.println(c1.getSimpleName());// Person

        // 自定义类的实例化对象，要找自定义类中的方法能找到
        // 现在自定义类是Class 的实例化对象，那么Class 类的实例化对象，找到自定义方法中的方法也很正常

        Method method = c1.getMethod("eat");
        // 7、System.out.println(method);

        // 根据下面代码执行结果来看，结果是一样的；
        // invoke 方法传入的是对象实例(因为eat 无参数列表，所以invoke没有第二个参数)
        p1.eat();

        // 8、
        method.invoke(p1);

        // 总结：
        // 自定义Person 类，类类型是Class
        // 为什么叫反射，正常流程是：类的实例化对象，对方法进行调用；
        // 现在反过来，Class 类的实例找到方法，再通过invoke 方法实现方法的调用；
    }

}

class Person {

    private String idCard;
    private String name;
    private Integer age;

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [idCard=" + idCard + ", name=" + name + ", age=" + age + "]";
    }

    public void eat() {
        System.out.println("eat 方法被调用了");
    }

}