public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//        创建properties对象
        Properties properties = new Properties();
//        加载文件
        properties.load(new FileReader("E:\\Codes\\myProject\\JiShiTongXun\\reflectionDemo\\re.properties"));
//        获取值
        String classpaht = properties.getProperty("classpaht");
        String method = properties.getProperty("method");
        System.out.println(classpaht);
//        使用反射机制创建类
//        ①加载类
        Class aClass = Class.forName(classpaht);
//        ②通过得到的aClass对象，可以得到加载的类（配置文件中的类）的实例
        ReflectionDemo rfd = (ReflectionDemo) aClass.newInstance();
//        ③得到方法的对象
        Method method1 = aClass.getMethod(method);
//        ④通过方法对象，调用方法
        method1.invoke(rfd);
    }
}

//①加载Class类，会返回一个Class类型的对象
        Class aClass = Class.forName("加载类全路径");

//①加载Class类，会返回一个Class类型的对象
            Class aClass = Class.forName(classpahttset);

// ③通过aClass得到加载类（Dog）的Method对象
        Method sayColor = aClass.getMethod("方法名");

//④通过Method对象，调用方法
        sayColor.invoke(aClass);

//        优化反射
        sayColor.setAccessible(true);

public class ClassDemo {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class aClass = Class.forName("com.zinksl.reflectionDemo.reflection01.Dog");
        //        获取包名
        String packgname = aClass.getPackage().getName();
        System.out.println(packgname);
        //        获取全类名
        System.out.println(aClass.getName());
        //        通过Class对象，创建需求类对象示例
        Dog dog = (Dog)aClass.newInstance();
        //        通过反射获取属性
        Field color = aClass.getField("color");
        String colors = (String) color.get(dog);
        System.out.println(colors);
        //        通过反射给属性设置值
        color.set(dog,"黄色");
        //        通过反射获取所有属性
        Field[] fields = aClass.getFields();
    }
}

public class ReflectGetObject {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//        1 先获取Person类的Class对象
        Class personClass = Class.forName("com.zinksl.reflectionDemo.reflectGetObject.Person");
//        2通过public无参构造器，创造实例
        Object o = personClass.newInstance();
        System.out.println(o);
//        3通过public有参构造器，创造实例
        //①先得到构造器
        Constructor constructor = personClass.getConstructor(String.class);
        //②通过构造器创建实例
        Object o1 = constructor.newInstance("马云");
        System.out.println(o1);
//        4 通过私有构造器，创造实例
        //先得到构造器
        Constructor constructor1 = personClass.getDeclaredConstructor(String.class,int.class,String.class);
//        爆破
        constructor1.setAccessible(true);//使用反射，创建私有化构造器，对象
        Object o2 = constructor1.newInstance("大黄", 80, "溜圈");
        System.out.println(o2);
    }
}
class Person{
    private String name ="码云";
    private int age = 20;
    public String hoby;
    public Person() {
    }
    public Person(String name){
        this.name = name;
    }
    private Person(String name, int age, String hoby) {
        this.name = name;
        this.age = age;
        this.hoby = hoby;
    }
    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }
    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }
    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }
    /**
     * 获取
     * @return hoby
     */
    public String getHoby() {
        return hoby;
    }
    /**
     * 设置
     * @param hoby
     */
    public void setHoby(String hoby) {
        this.hoby = hoby;
    }
    public String toString() {
        return "Person{name = " + name + ", age = " + age + ", hoby = " + hoby + "}";
    }
}

public class ReflectionGetShuxing {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException, IllegalAccessException, InvocationTargetException, InstantiationException {
//1获得Class类对象
        Class<?> aClass = Class.forName("com.zinksl.reflectionDemo.reflectGetObject.Person2");
//        2创建对象
        Object o = aClass.newInstance();
//        3 获取Field的对象
        Field hoby = aClass.getField("hoby");
//        4 设置属性
        hoby.set(o,"抽烟喝酒烫头");
        System.out.println(o);
        Field age = aClass.getDeclaredField("age");
        age.setAccessible(true);
        age.set(o,9999);
        System.out.println(o);
    }
}
class Person2{
    private static String name ="码云";
    private int age = 20;
    public String hoby;
    public Person2() {
    }
    public Person2(String name){
        this.name = name;
    }
    private Person2(String name, int age, String hoby) {
        this.name = name;
        this.age = age;
        this.hoby = hoby;
    }
    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }
    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }
    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }
    /**
     * 获取
     * @return hoby
     */
    public String getHoby() {
        return hoby;
    }
    /**
     * 设置
     * @param hoby
     */
    public void setHoby(String hoby) {
        this.hoby = hoby;
    }
    public String toString() {
        return "Person{name = " + name + ", age = " + age + ", hoby = " + hoby + "}";
    }
}