Java反射總結歸納

Java的反射很重要　作用有兩個獲取反射類型和反射調用(下面我會都說到,網上大多說的用法不全面)

獲取Class

Class<Demo> c = Demo.class;//第一種方法
Class<?> c = Class.forName("package14_Demo");//第二種方式

code 準備
User.java

import java.io.Serializable;

/**
 * Created by zhou on 18-1-16.
 */
abstract public class User implements Serializable {
    public String name = "blake";
    private int age = (int) StrictMath.round(StrictMath.random() * 1000);
    private String address = (char) StrictMath.round(StrictMath.random() * 100000) + "" + (char) StrictMath.round(StrictMath.random() * 100000);

    protected User(int age, String address) {
        this.age = age;
        this.address = address;
    }

    public User() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

method

method的獲取以及通過反射調用

public class Demo1 extends User{
    public void info() {
        System.out.println("info():" + "xxxxx ddd ggh");
    }

    protected void log() {
        System.out.println("Is China's position on property market thawing?");
    }

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, Exception {
        {
            Class<?> c = Class.forName("com.code14.c2.Demo1");
            System.out.println("class name:" + c.getSimpleName());
            /*獲取所有的public修飾的方法 包括父類的方法*/
            Method[] methods = c.getMethods();
            for (Method m : methods) {
                System.out.println("method = [" + m.getName() + "]");
            }
            /**
             * 從打印結果看getMethods()獲取了Object和User以及自身的所有被public修飾過的method
             */
        }

        System.out.println("-----------------------------------------||------------------------------------");

        {
            Class<?> c = Demo1.class;
            /*獲取class對象的所有聲明方法:建議平時儘量使用getDeclaredMethods()*/
            Method[] methods = c.getDeclaredMethods();
            for (Method m : methods) {
                System.out.println("method = [" + m.getName() + "]");
            }
            /**
             * 從打印結果看:獲取了自身所有定義過的所有方法
             */
        }

        System.out.println(".........................................||.....................................");

        {
            //當利用反射具體創建對象的時候必須要明確具體的類型
            Class<Demo1> c = Demo1.class;
            Demo1 demo = c.newInstance();
            demo.info();

            Method m = null;
            try {
                m = c.getMethod("log", null);
                //由於方法沒有參數,所以不用傳入,假如有一個參數並且切好又是String,那麼只需傳入String.class即可
            }catch (NoSuchMethodException e){
                System.out.println("拋出異常:"+e.getMessage());
                //拋出異常NoSuchMethodException 原來我的method用了 protected修飾
            }

            //具體使用
            m = c.getDeclaredMethod("log", null);
            m.invoke(demo, null);//傳入的是對象而不是class
            m = c.getMethod("getAddress",null);
            System.out.println(m.invoke(demo, null));

            m = c.getMethod("setAddress",String.class);
            m.invoke(demo, "china");

            m = c.getMethod("getAddress",null);
            System.out.println(m.invoke(demo, null));
        }
    }
}

field

public class Demo2 extends User {
    private String account = (char) StrictMath.round(StrictMath.random() * 1000) + "" + (char) StrictMath.round(StrictMath.random() * 1000);
    private double money = StrictMath.random() * 100;


    public static void runB() throws Exception {
        Class<?> demo = Class.forName("com.code14.c2.Demo2");
        Field account = demo.getDeclaredField("account");
        Field money = demo.getDeclaredField("money");
        System.out.println("field Name:" + account.getName());
        System.out.println("field Name:" + money.getName());
        try {
            Field f = demo.getDeclaredField("name");
            System.out.println(f.getName() + "異常!不會打印");
        } catch (Exception e) {
            System.out.println("exception:" + e.getMessage());
        }
        /**
         * 我們可以看到getDeclaredField()和getDeclaredFields()用法其實差不多的都是獲取當前類的字段(當前類中任意修飾符都可以獲取)
         * 如果獲取父類的字段會拋出異常
         */
        System.out.println("----------------------------------||-------------------------");
        //現在我們來看看如何獲取field 上的value  具體使用
        Demo2 demo2 = (Demo2) demo.newInstance();//get Demo2 Object
        double m = (double) money.get(demo2);
        String s = (String) account.get(demo2);
        System.out.println("money value:" + m);
        System.out.println("account value:" + s);
        /**
         * 能夠正常的獲取field上的value
         */
    }

    public static void runA() throws NoSuchFieldException, IllegalAccessException {
        Class<Demo2> demo = Demo2.class;
        Field name = demo.getField("name");
        System.out.println("name:" + name);

        Field age = demo.getField("age");//從這開始異常,因爲後面４個全部是非public修飾過的
        Field address = demo.getField("address");
        Field account = demo.getField("account");
        Field money = demo.getField("money");
        System.out.println("age:" + age);
        System.out.println("address:" + address);
        System.out.println("account:" + account);
        System.out.println("money:" + money);
        /**
         * getField()我們可以看到和getFields()相似都是獲取public修飾過的字段並且都是子類和父類都可以獲取
         */
    }

    public static void startA() throws Exception {
        Class<?> demo = Class.forName("com.code14.c2.Demo2");
        Field[] fields = demo.getFields();
        for (Field f : fields) {
            System.out.println("field Name:" + f.getName());
        }
        /**
         * 打印結果:field Name:name
         * 我們可以看到只有父類的User中的name字段被打印
         * getFields()可以被確定爲所有子類與父類的被public修飾過的字段
         */
    }

    public static void startB() throws Exception {
        Class<Demo2> demo = Demo2.class;
        Field[] fields = demo.getDeclaredFields();
        for (Field f : fields) {
            System.out.println("field Name:" + f.getName());
        }
        /**
         * 打印結果:
         * field Name:account
         * field Name:money
         * 如結果我們可以知道getDeclaredFields()獲取當前類的所有定義的字段(修飾符可以是任意)
         */
    }


    public static void main(String[] args) throws Exception {
        runB();
    }
}

Constructos

public class Demo3 extends User {
    private String account = (char) StrictMath.round(StrictMath.random() * 1000) + "" + (char) StrictMath.round(StrictMath.random() * 1000);
    private double money = StrictMath.random() * 100;

    public static void main(String[] args) throws Exception {
        runC();
    }

    /**
     * 構造器的具體使用
     *
     * @throws Exception
     */
    public static void runC() throws Exception {
        Class<Demo3> demo3Class = Demo3.class;
        Constructor<Demo3> demo3Constructor = demo3Class.getDeclaredConstructor(String.class, double.class);
        Demo3 demo3 = demo3Constructor.newInstance("blake", StrictMath.round(StrictMath.random() * 100));
        System.out.println("account:" + demo3.getAccount());
        System.out.println("money:" + demo3.getMoney());

        //Constructor沒有參數那麼就不需要傳入參數
        demo3Constructor = demo3Class.getDeclaredConstructor();
        demo3 = demo3Constructor.newInstance();
        System.out.println("account:" + demo3.getAccount());
        System.out.println("money:" + demo3.getMoney());
    }


    public static void runB() throws Exception {
        Class<?> demo3Class = Class.forName("com.code14.c2.Demo3", true, Demo3.class.getClassLoader());
        //public Constructor<T> getConstructor(Class<?>... parameterTypes) jdk中的參數爲可變數組

        //public Demo3(String account, double money)打印結果如下:public com.code14.c2.Demo3(java.lang.String,double)
        Constructor<?> c4 = demo3Class.getDeclaredConstructor(String.class, double.class);

        /*public Demo3(int age, String address, String account, double money)
        * 打印結果如下:public com.code14.c2.Demo3(int,java.lang.String,java.lang.String,double)*/
        Constructor<?> c3 = demo3Class.getDeclaredConstructor(int.class, String.class, String.class, double.class);

        //public Demo3(int age, String address) 打印結果:public com.code14.c2.Demo3(int,java.lang.String)
        Constructor<?> c2 = demo3Class.getDeclaredConstructor(int.class, String.class);

        //public Demo3() 打印結果如下com.code14.c2.Demo3()
        Constructor<?> c1 = demo3Class.getDeclaredConstructor();

        /**
         * 從上面可以看到獲取構造器的method getDeclaredConstructor()和getDeclaredConstructors()用法差不多
         *同樣需要注意的是它的參數順序和參數類型的class數量
         * getDeclaredConstructor()可以獲取class的所有構造器但不包括父類的構造器
         */
    }

    public static void runA() throws Exception {
        Class<?> demo3Class = Class.forName("com.code14.c2.Demo3", true, Demo3.class.getClassLoader());
        //public Constructor<T> getConstructor(Class<?>... parameterTypes) jdk中的參數爲可變數組

        //public Demo3(String account, double money)打印結果如下:public com.code14.c2.Demo3(java.lang.String,double)
        Constructor<?> c4 = demo3Class.getConstructor(String.class, double.class);

        /*public Demo3(int age, String address, String account, double money)
        * 打印結果如下:public com.code14.c2.Demo3(int,java.lang.String,java.lang.String,double)*/
        Constructor<?> c3 = demo3Class.getConstructor(int.class, String.class, String.class, double.class);

        //public Demo3(int age, String address) 打印結果:public com.code14.c2.Demo3(int,java.lang.String)
        Constructor<?> c2 = demo3Class.getConstructor(int.class, String.class);

        //Constructor<?> c1 = demo3Class.getConstructor();//c1 拋出異常,不能夠獲取因爲是default修飾過的

        /**
         * 從上面可以看到獲取構造器的method getConstructor()和getConstructors()用法基本差不多,只是getConstructor()
         * 獲取單個構造器,這個method要注意的是傳入參數的class必須注意順序和個數.很重要哦!
         */
    }

    public static void startA() throws Exception {
        Class<?> demo3Class = Class.forName("com.code14.c2.Demo3", true, Demo3.class.getClassLoader());
        Constructor<?>[] constructors = demo3Class.getConstructors();
        for (Constructor<?> c : constructors) {
            System.out.println("name:" + c.getName());
        }
        /**打印結果如下:
         * name:com.code14.c2.Demo3
         * name:com.code14.c2.Demo3
         * name:com.code14.c2.Demo3
         */
        /*我們可以看到getConstructors()只能夠獲取被public修飾的Constructor method
        * 並且連父類被public修飾過的Constructor也不能夠被獲取這和Field以及Method很不一樣*/
    }

    public static void startB() throws Exception {
        Class<Demo3> demo3Class = Demo3.class;
        Constructor<?>[] constructors = demo3Class.getDeclaredConstructors();
        for (Constructor<?> c : constructors) {
            System.out.println("name:" + c.getName());
        }
        /**
         * name:com.code14.c2.Demo3
         * name:com.code14.c2.Demo3
         * name:com.code14.c2.Demo3
         * name:com.code14.c2.Demo3
         * 從結果上看到獲取了當前類的四個構造器,依然沒有獲取超類的構造器
         * 因此我們可以說getDeclaredConstructors()可以獲取當前類所有的構造器(任何修飾符修飾過的都可以獲取)
         */
    }

    public String getAccount() {
        return account;
    }


    /**
     * super Constructs
     *
     * @param age
     * @param address
     */
    public Demo3(int age, String address) {
        super(age, address);
    }


    public Demo3(int age, String address, String account, double money) {
        super(age, address);
        this.account = account;
        this.money = money;
    }

    public Demo3(String account, double money) {
        this.account = account;
        this.money = money;
    }

    Demo3() {
    }

    public double getMoney() {
        return money;
    }


}

copy 跑起來就一目瞭然了