public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用類的class屬性來獲取該類對應(yīng)的Class對象
        Class<Student> c1 = Student.class;
        System.out.println(c1);
 
        Class<Student> c2 = Student.class;
        System.out.println(c1 == c2);
        System.out.println("--------");
 
        //調(diào)用對象的getClass()方法，返回該對象所屬類對應(yīng)的Class對象
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        System.out.println("--------");
 
        //使用Class類中的靜態(tài)方法forName(String className)
        Class<?> c4 = Class.forName("com.itheima_02.Student");
        System.out.println(c1 == c4);
    }
}

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //獲取Class對象
        Class<?> c = Class.forName("com.itheima_02.Student");
 
        //Constructor<?>[] getConstructors() 返回一個包含 Constructor對象的數(shù)組， Constructor對象反映了由該 Class對象表示的類的所有公共構(gòu)造函數(shù)
//        Constructor<?>[] cons = c.getConstructors();
        //Constructor<?>[] getDeclaredConstructors() 返回反映由該 Class對象表示的類聲明的所有構(gòu)造函數(shù)的 Constructor對象的數(shù)組
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for(Constructor con : cons) {
            System.out.println(con);
        }
        System.out.println("--------");
 
        //Constructor<T> getConstructor(Class<?>... parameterTypes) 返回一個 Constructor對象，該對象反映由該 Class對象表示的類的指定公共構(gòu)造函數(shù)
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回一個 Constructor對象，該對象反映由此 Class對象表示的類或接口的指定構(gòu)造函數(shù)
        //參數(shù)：你要獲取的構(gòu)造方法的參數(shù)的個數(shù)和數(shù)據(jù)類型對應(yīng)的字節(jié)碼文件對象
 
        Constructor<?> con = c.getConstructor();
 
        //Constructor提供了一個類的單個構(gòu)造函數(shù)的信息和訪問權(quán)限
        //T newInstance(Object... initargs) 使用由此 Constructor對象表示的構(gòu)造函數(shù)，使用指定的初始化參數(shù)來創(chuàng)建和初始化構(gòu)造函數(shù)的聲明類的新實例
        Object obj = con.newInstance();
        System.out.println(obj);
 
//        Student s = new Student();
//        System.out.println(s);
    }
}

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //獲取Class對象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Field[] getFields() 返回一個包含 Field對象的數(shù)組， Field對象反映由該 Class對象表示的類或接口的所有可訪問的公共字段
        //Field[] getDeclaredFields() 返回一個 Field對象的數(shù)組，反映了由該 Class對象表示的類或接口聲明的所有字段
//        Field[] fields = c.getFields();
        Field[] fields = c.getDeclaredFields();
        for(Field field : fields) {
            System.out.println(field);
        }
        System.out.println("--------");
        //Field getField(String name) 返回一個 Field對象，該對象反映由該 Class對象表示的類或接口的指定公共成員字段
        //Field getDeclaredField(String name) 返回一個 Field對象，該對象反映由該 Class對象表示的類或接口的指定聲明字段
        Field addressField = c.getField("address");
        //獲取無參構(gòu)造方法創(chuàng)建對象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
 
//        obj.addressField = "西安";
        //Field提供有關(guān)類或接口的單個字段的信息和動態(tài)訪問
        //void set(Object obj, Object value) 將指定的對象參數(shù)中由此 Field對象表示的字段設(shè)置為指定的新值
        addressField.set(obj,"西安"); //給obj的成員變量addressField賦值為西安
 
        System.out.println(obj);
 
 
 
//        Student s = new Student();
//        s.address = "西安";
//        System.out.println(s);
    }
}

public class ReflectDemo01 {
    public static void main(String[] args) throws Exception {
        //獲取Class對象
        Class<?> c = Class.forName("com.itheima_02.Student");
        //Method[] getMethods() 返回一個包含 方法對象的數(shù)組， 方法對象反映由該 Class對象表示的類或接口的所有公共方法，包括由類或接口聲明的對象以及從超類和超級接口繼承的類
        //Method[] getDeclaredMethods() 返回一個包含 方法對象的數(shù)組， 方法對象反映由 Class對象表示的類或接口的所有聲明方法，包括public，protected，default（package）訪問和私有方法，但不包括繼承方法
//        Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for(Method method : methods) {
            System.out.println(method);
        }
        System.out.println("--------");
        //Method getMethod(String name, Class<?>... parameterTypes) 返回一個 方法對象，該對象反映由該 Class對象表示的類或接口的指定公共成員方法
        //Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回一個 方法對象，它反映此表示的類或接口的指定聲明的方法 Class對象
        //public void method1()
        Method m = c.getMethod("method1");
 
        //獲取無參構(gòu)造方法創(chuàng)建對象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
//        obj.m();
        //在類或接口上提供有關(guān)單一方法的信息和訪問權(quán)限
        //Object invoke(Object obj, Object... args) 在具有指定參數(shù)的指定對象上調(diào)用此 方法對象表示的基礎(chǔ)方法
        //Object：返回值類型
        //obj：調(diào)用方法的對象
        //args：方法需要的參數(shù)
        m.invoke(obj);
    }
}

public class ReflectTest01 {
    public static void main(String[] args) throws Exception {
        //創(chuàng)建集合
        ArrayList<Integer> array = new ArrayList<Integer>();
 
//        array.add(10);
//        array.add(20);
//        array.add("hello");
        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add", Object.class);
 
        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");
 
        System.out.println(array);
    }
}

public class ReflectTest02 {
    public static void main(String[] args) throws Exception {
        //加載數(shù)據(jù)
        Properties prop = new Properties();
        FileReader fr = new FileReader("myReflect\\class.txt");
        prop.load(fr);
        fr.close();
        /*
            className=com.itheima_06.Student
            methodName=study
         */
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");
 
        //通過反射來使用
        Class<?> c = Class.forName(className);//com.itheima_06.Student
 
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
 
        Method m = c.getMethod(methodName);//study
        m.invoke(obj);
    }
}