java反射詳解

原創 肖权 2020-02-23 13:47

轉載至：http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html


本篇文章依舊採用小例子來說明，因爲我始終覺的，案例驅動是最好的，要不然只看理論的話，看了也不懂，不過建議大家在看完文章之後，在回過頭去看看理論，會有更好的理解。

下面開始正文。

【案例1】通過一個對象獲得完整的包名和類名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package Reflect;
 
/**
 * 通過一個對象獲得完整的包名和類名
 * */
class Demo{
    //other codes...
}
 
class hello{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
}

【運行結果】：Reflect.Demo

添加一句：所有類的對象其實都是Class的實例。

【案例2】實例化Class類對象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package Reflect;
class Demo{
    //other codes...
}
 
class hello{
    public static void main(String[] args) {
        Class<?> demo1=null;
        Class<?> demo2=null;
        Class<?> demo3=null;
        try{
            //一般儘量採用這種形式
            demo1=Class.forName("Reflect.Demo");
        }catch(Exception e){
            e.printStackTrace();
        }
        demo2=new Demo().getClass();
        demo3=Demo.class;
         
        System.out.println("類名稱   "+demo1.getName());
        System.out.println("類名稱   "+demo2.getName());
        System.out.println("類名稱   "+demo3.getName());
         
    }
}

【運行結果】：

類名稱   Reflect.Demo

類名稱   Reflect.Demo

類名稱   Reflect.Demo

【案例3】通過Class實例化其他類的對象

通過無參構造實例化對象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package Reflect;
 
class Person{
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }
    private String name;
    private int age;
}
 
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per=null;
        try {
            per=(Person)demo.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        per.setName("Rollen");
        per.setAge(20);
        System.out.println(per);
    }
}

【運行結果】：

[Rollen  20]

但是注意一下，當我們把Person中的默認的無參構造函數取消的時候，比如自己定義只定義一個有參數的構造函數之後，會出現錯誤：

比如我定義了一個構造函數：

1
2
3
4
public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }

然後繼續運行上面的程序，會出現：

java.lang.InstantiationException: Reflect.Person

    at java.lang.Class.newInstance0(Class.java:340)

    at java.lang.Class.newInstance(Class.java:308)

    at Reflect.hello.main(hello.java:39)

Exception in thread "main" java.lang.NullPointerException

    at Reflect.hello.main(hello.java:47)

所以大家以後再編寫使用Class實例化其他類的對象的時候，一定要自己定義無參的構造函數

 

【案例】通過Class調用其他類中的構造函數 （也可以通過這種方式通過Class創建其他類的對象）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package Reflect;
 
import java.lang.reflect.Constructor;
 
class Person{
     
    public Person() {
         
    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        this.age=age;
    }
    public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }
    private String name;
    private int age;
}
 
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per1=null;
        Person per2=null;
        Person per3=null;
        Person per4=null;
        //取得全部的構造函數
        Constructor<?> cons[]=demo.getConstructors();
        try{
            per1=(Person)cons[0].newInstance();
            per2=(Person)cons[1].newInstance("Rollen");
            per3=(Person)cons[2].newInstance(20);
            per4=(Person)cons[3].newInstance("Rollen",20);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);
    }
}

【運行結果】：

[null  0]

[Rollen  0]

[null  20]

[Rollen  20]

【案例】 

返回一個類實現的接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package Reflect;
 
interface China{
    public static final String name="Rollen";
    public static  int age=20;
    public void sayChina();
    public void sayHello(String name, int age);
}
 
class Person implements China{
    public Person() {
         
    }
    public Person(String sex){
        this.sex=sex;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public void sayChina(){
        System.out.println("hello ,china");
    }
    @Override
    public void sayHello(String name, int age){
        System.out.println(name+"  "+age);
    }
    private String sex;
}
 
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        //保存所有的接口
        Class<?> intes[]=demo.getInterfaces();
        for (int i = 0; i < intes.length; i++) {
            System.out.println("實現的接口   "+intes[i].getName());
        }
    }
}

【運行結果】：

實現的接口   Reflect.China

（注意，以下幾個例子，都會用到這個例子的Person類，所以爲節省篇幅，此處不再粘貼Person的代碼部分，只粘貼主類hello的代碼）

【案例】：取得其他類中的父類

1
2
3
4
5
6
7
8
9
10
11
12
13
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        //取得父類
        Class<?> temp=demo.getSuperclass();
        System.out.println("繼承的父類爲：   "+temp.getName());
    }
}

【運行結果】

繼承的父類爲：   java.lang.Object

【案例】：獲得其他類中的全部構造函數

這個例子需要在程序開頭添加import java.lang.reflect.*;

然後將主類編寫爲：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Constructor<?>cons[]=demo.getConstructors();
        for (int i = 0; i < cons.length; i++) {
            System.out.println("構造方法：  "+cons[i]);
        }
    }
}

【運行結果】：

構造方法：  public Reflect.Person()

構造方法：  public Reflect.Person(java.lang.String)

但是細心的讀者會發現，上面的構造函數沒有public 或者private這一類的修飾符

下面這個例子我們就來獲取修飾符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Constructor<?>cons[]=demo.getConstructors();
        for (int i = 0; i < cons.length; i++) {
            Class<?> p[]=cons[i].getParameterTypes();
            System.out.print("構造方法：  ");
            int mo=cons[i].getModifiers();
            System.out.print(Modifier.toString(mo)+" ");
            System.out.print(cons[i].getName());
            System.out.print("(");
            for(int j=0;j<p.length;++j){
                System.out.print(p[j].getName()+" arg"+i);
                if(j<p.length-1){
                    System.out.print(",");
                }
            }
            System.out.println("){}");
        }
    }
}

【運行結果】：

構造方法：  public Reflect.Person(){}

構造方法：  public Reflect.Person(java.lang.String arg1){}

有時候一個方法可能還有異常，呵呵。下面看看：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Method method[]=demo.getMethods();
        for(int i=0;i<method.length;++i){
            Class<?> returnType=method[i].getReturnType();
            Class<?> para[]=method[i].getParameterTypes();
            int temp=method[i].getModifiers();
            System.out.print(Modifier.toString(temp)+" ");
            System.out.print(returnType.getName()+"  ");
            System.out.print(method[i].getName()+" ");
            System.out.print("(");
            for(int j=0;j<para.length;++j){
                System.out.print(para[j].getName()+" "+"arg"+j);
                if(j<para.length-1){
                    System.out.print(",");
                }
            }
            Class<?> exce[]=method[i].getExceptionTypes();
            if(exce.length>0){
                System.out.print(") throws ");
                for(int k=0;k<exce.length;++k){
                    System.out.print(exce[k].getName()+" ");
                    if(k<exce.length-1){
                        System.out.print(",");
                    }
                }
            }else{
                System.out.print(")");
            }
            System.out.println();
        }
    }
}

【運行結果】：

public java.lang.String  getSex ()

public void  setSex (java.lang.String arg0)

public void  sayChina ()

public void  sayHello (java.lang.String arg0,int arg1)

public final native void  wait (long arg0) throws java.lang.InterruptedException

public final void  wait () throws java.lang.InterruptedException

public final void  wait (long arg0,int arg1) throws java.lang.InterruptedException

public boolean  equals (java.lang.Object arg0)

public java.lang.String  toString ()

public native int  hashCode ()

public final native java.lang.Class  getClass ()

public final native void  notify ()

public final native void  notifyAll ()

【案例】接下來讓我們取得其他類的全部屬性吧，最後我講這些整理在一起，也就是通過class取得一個類的全部框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class hello {
    public static void main(String[] args) {
        Class<?> demo = null;
        try {
            demo = Class.forName("Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("===============本類屬性========================");
        // 取得本類的全部屬性
        Field[] field = demo.getDeclaredFields();
        for (int i = 0; i < field.length; i++) {
            // 權限修飾符
            int mo = field[i].getModifiers();
            String priv = Modifier.toString(mo);
            // 屬性類型
            Class<?> type = field[i].getType();
            System.out.println(priv + " " + type.getName() + " "
                    + field[i].getName() + ";");
        }
        System.out.println("===============實現的接口或者父類的屬性========================");
        // 取得實現的接口或者父類的屬性
        Field[] filed1 = demo.getFields();
        for (int j = 0; j < filed1.length; j++) {
            // 權限修飾符
            int mo = filed1[j].getModifiers();
            String priv = Modifier.toString(mo);
            // 屬性類型
            Class<?> type = filed1[j].getType();
            System.out.println(priv + " " + type.getName() + " "
                    + filed1[j].getName() + ";");
        }
    }
}

【運行結果】：

===============本類屬性========================

private java.lang.String sex;

===============實現的接口或者父類的屬性========================

public static final java.lang.String name;

public static final int age;

【案例】其實還可以通過反射調用其他類中的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class hello {
    public static void main(String[] args) {
        Class<?> demo = null;
        try {
            demo = Class.forName("Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            //調用Person類中的sayChina方法
            Method method=demo.getMethod("sayChina");
            method.invoke(demo.newInstance());
            //調用Person的sayHello方法
            method=demo.getMethod("sayHello", String.class,int.class);
            method.invoke(demo.newInstance(),"Rollen",20);
             
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　【運行結果】：

hello ,china

Rollen  20

【案例】調用其他類的set和get方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class hello {
    public static void main(String[] args) {
        Class<?> demo = null;
        Object obj=null;
        try {
            demo = Class.forName("Reflect.Person");
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
         obj=demo.newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        setter(obj,"Sex","男",String.class);
        getter(obj,"Sex");
    }
 
    /**
     * @param obj
     *            操作的對象
     * @param att
     *            操作的屬性
     * */
    public static void getter(Object obj, String att) {
        try {
            Method method = obj.getClass().getMethod("get" + att);
            System.out.println(method.invoke(obj));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @param obj
     *            操作的對象
     * @param att
     *            操作的屬性
     * @param value
     *            設置的值
     * @param type
     *            參數的屬性
     * */
    public static void setter(Object obj, String att, Object value,
            Class<?> type) {
        try {
            Method method = obj.getClass().getMethod("set" + att, type);
            method.invoke(obj, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}// end class

【運行結果】：

男

 【案例】通過反射操作屬性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class hello {
    public static void main(String[] args) throws Exception {
        Class<?> demo = null;
        Object obj = null;
 
        demo = Class.forName("Reflect.Person");
        obj = demo.newInstance();
 
        Field field = demo.getDeclaredField("sex");
        field.setAccessible(true);
        field.set(obj, "男");
        System.out.println(field.get(obj));
    }
}// end class

【案例】通過反射取得並修改數組的信息：

1
2
3
4
5
6
7
8
9
10
11
12
import java.lang.reflect.*;
class hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5};
        Class<?>demo=temp.getClass().getComponentType();
        System.out.println("數組類型： "+demo.getName());
        System.out.println("數組長度  "+Array.getLength(temp));
        System.out.println("數組的第一個元素: "+Array.get(temp, 0));
        Array.set(temp, 0, 100);
        System.out.println("修改之後數組第一個元素爲： "+Array.get(temp, 0));
    }
}

【運行結果】：

數組類型： int

數組長度  5

數組的第一個元素: 1

修改之後數組第一個元素爲： 100

【案例】通過反射修改數組大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class hello{
    public static void main(String[] args) {
        int[] temp={1,2,3,4,5,6,7,8,9};
        int[] newTemp=(int[])arrayInc(temp,15);
        print(newTemp);
        System.out.println("=====================");
        String[] atr={"a","b","c"};
        String[] str1=(String[])arrayInc(atr,8);
        print(str1);
    }
     
    /**
     * 修改數組大小
     * */
    public static Object arrayInc(Object obj,int len){
        Class<?>arr=obj.getClass().getComponentType();
        Object newArr=Array.newInstance(arr, len);
        int co=Array.getLength(obj);
        System.arraycopy(obj, 0, newArr, 0, co);
        return newArr;
    }
    /**
     * 打印
     * */
    public static void print(Object obj){
        Class<?>c=obj.getClass();
        if(!c.isArray()){
            return;
        }
        System.out.println("數組長度爲： "+Array.getLength(obj));
        for (int i = 0; i < Array.getLength(obj); i++) {
            System.out.print(Array.get(obj, i)+" ");
        }
    }
}

【運行結果】：

數組長度爲： 15

1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================

數組長度爲： 8

a b c null null null null null

動態代理

【案例】首先來看看如何獲得類加載器：

1
2
3
4
5
6
7
8
9
class test{
     
}
class hello{
    public static void main(String[] args) {
        test t=new test();
        System.out.println("類加載器  "+t.getClass().getClassLoader().getClass().getName());
    }
}

【程序輸出】：

類加載器  sun.misc.Launcher$AppClassLoader

其實在java中有三種類類加載器。

1）Bootstrap ClassLoader 此加載器採用c++編寫，一般開發中很少見。

2）Extension ClassLoader 用來進行擴展類的加載，一般對應的是jre\lib\ext目錄中的類

3）AppClassLoader 加載classpath指定的類，是最常用的加載器。同時也是java中默認的加載器。

如果想要完成動態代理，首先需要定義一個InvocationHandler接口的子類，已完成代理的具體操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package Reflect;
import java.lang.reflect.*;
 
//定義項目接口
interface Subject {
    public String say(String name, int age);
}
 
// 定義真實項目
class RealSubject implements Subject {
    @Override
    public String say(String name, int age) {
        return name + "  " + age;
    }
}
 
class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;
 
    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}
 
class hello {
    public static void main(String[] args) {
        MyInvocationHandler demo = new MyInvocationHandler();
        Subject sub = (Subject) demo.bind(new RealSubject());
        String info = sub.say("Rollen", 20);
        System.out.println(info);
    }
}

【運行結果】：

Rollen  20

類的生命週期

在一個類編譯完成之後，下一步就需要開始使用類，如果要使用一個類，肯定離不開JVM。在程序執行中JVM通過裝載，鏈接，初始化這3個步驟完成。

類的裝載是通過類加載器完成的，加載器將.class文件的二進制文件裝入JVM的方法區，並且在堆區創建描述這個類的java.lang.Class對象。用來封裝數據。 但是同一個類只會被類裝載器裝載以前

鏈接就是把二進制數據組裝爲可以運行的狀態。

 

鏈接分爲校驗，準備，解析這3個階段

校驗一般用來確認此二進制文件是否適合當前的JVM（版本），

準備就是爲靜態成員分配內存空間，。並設置默認值

解析指的是轉換常量池中的代碼作爲直接引用的過程，直到所有的符號引用都可以被運行程序使用（建立完整的對應關係）

完成之後，類型也就完成了初始化，初始化之後類的對象就可以正常使用了，直到一個對象不再使用之後，將被垃圾回收。釋放空間。

當沒有任何引用指向Class對象時就會被卸載，結束類的生命週期

將反射用於工廠模式

先來看看，如果不用反射的時候，的工廠模式吧：

http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/**
 * @author Rollen-Holt 設計模式之 工廠模式
 */
 
interface fruit{
    public abstract void eat();
}
 
class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}
 
class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}
 
// 構造工廠類
// 也就是說以後如果我們在添加其他的實例的時候只需要修改工廠類就行了
class Factory{
    public static fruit getInstance(String fruitName){
        fruit f=null;
        if("Apple".equals(fruitName)){
            f=new Apple();
        }
        if("Orange".equals(fruitName)){
            f=new Orange();
        }
        return f;
    }
}
class hello{
    public static void main(String[] a){
        fruit f=Factory.getInstance("Orange");
        f.eat();
    }
 
}

這樣，當我們在添加一個子類的時候，就需要修改工廠類了。如果我們添加太多的子類的時候，改的就會很多。

現在我們看看利用反射機制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package Reflect;
 
interface fruit{
    public abstract void eat();
}
 
class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}
 
class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}
 
class Factory{
    public static fruit getInstance(String ClassName){
        fruit f=null;
        try{
            f=(fruit)Class.forName(ClassName).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
class hello{
    public static void main(String[] a){
        fruit f=Factory.getInstance("Reflect.Apple");
        if(f!=null){
            f.eat();
        }
    }
}

現在就算我們添加任意多個子類的時候，工廠類就不需要修改。

 

上面的愛嗎雖然可以通過反射取得接口的實例，但是需要傳入完整的包和類名。而且用戶也無法知道一個接口有多少個可以使用的子類，所以我們通過屬性文件的形式配置所需要的子類。

下面我們來看看： 結合屬性文件的工廠模式

首先創建一個fruit.properties的資源文件，

內容爲：

1
2
apple=Reflect.Apple
orange=Reflect.Orange

　然後編寫主類代碼：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package Reflect;
 
import java.io.*;
import java.util.*;
 
interface fruit{
    public abstract void eat();
}
 
class Apple implements fruit{
    public void eat(){
        System.out.println("Apple");
    }
}
 
class Orange implements fruit{
    public void eat(){
        System.out.println("Orange");
    }
}
 
//操作屬性文件類
class init{
    public static Properties getPro() throws FileNotFoundException, IOException{
        Properties pro=new Properties();
        File f=new File("fruit.properties");
        if(f.exists()){
            pro.load(new FileInputStream(f));
        }else{
            pro.setProperty("apple", "Reflect.Apple");
            pro.setProperty("orange", "Reflect.Orange");
            pro.store(new FileOutputStream(f), "FRUIT CLASS");
        }
        return pro;
    }
}
 
class Factory{
    public static fruit getInstance(String ClassName){
        fruit f=null;
        try{
            f=(fruit)Class.forName(ClassName).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}
class hello{
    public static void main(String[] a) throws FileNotFoundException, IOException{
        Properties pro=init.getPro();
        fruit f=Factory.getInstance(pro.getProperty("apple"));
        if(f!=null){
            f.eat();
        }
    }
}

【運行結果】：Apple


發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

mybatis-reflection反射包解析

反射包解析 概述 mybatis反射包，提供了反射相關的工具，爲啥要提供這些工具呢，java不是已經提供反射的功能了嗎？ java反射雖然已經很強大，但是api偏底層，要想使用好可能會需要大量重複代碼，可能使用不當也會產生性能問題

请叫我程序猿大人 2020-07-08 08:38:26

Java反射異常:java.lang.IllegalArgumentException: wrong number of arguments

在用反射調用Hello.java的main方法時報了一個異常 java.lang.IllegalArgumentException: wrong number of arguments Hello.java package cl

infoflow 2020-07-07 23:03:12

面試題——單例模式與反射、序列化

餓漢式 立即加載，線程安全。 public class Singleton { private static Singleton INSTANCE = new Singleton();//立即加載 private

吴声子夜歌 2020-07-07 01:09:47

千鋒逆戰班，學習了反射

學習Java的第52天， 明天的自己會感謝今天拼命的自己 今天學習了反射的類加載，類加載器，類反射機制，工廠模式，反射機制操作構造器，成員變量，成員函數，反射機制跳過泛型的限制，反射機制配置文件，靜待代理設計模式 類加載 概念：

卤蛋小白 2020-07-07 00:04:23

java 反射以及jdk動態代碼

<code></code><pre name="code" class="java"><code style="background-color: rgb(255, 255, 255);"></code><pre name="code"

Tracysw 2020-07-06 22:45:23

Java反射獲取對象屬性 以及值

import java.beans.IntrospectionException; import java.beans.PropertyDescriptor; import java.lang.reflect.Field; impor

bobo_许 2020-07-06 18:38:04

自定義註解利用反射記錄日誌

場景： 項目中有一個供應商模塊，包含供應商的基礎信息、供應商資質等，字段比較多，其中有些信息比較重要，如果修改了需要記錄修改日誌（如哪個信息從什麼改爲什麼），同時還需要重新提交，而有些信息修改了值需要記下日誌，並不需要重新審覈，還

梵晞 2020-07-06 16:50:36

通過表達式樹實現，根據名稱獲取或設置對象屬性值（性能相較於反射而言要快1~2倍）

一、介紹 在日常的開發過程中會出現，需要根據名稱來獲取某個未知對象的屬性，常用的方式是使用反射來完成此類效果，但是反射在性能方面要比較差，所以這個組件是使用反射+表達式樹來實現的獲取、設置屬性值，在性能上要比純反射速度要快1~2

AI255 2020-07-06 16:45:33

——java中的反射

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity開發</a>、<a href="http://www.itheima.

qq_17045409 2020-07-05 23:42:03

基於java反射的類型轉換工具類

適用於數據持久層pojo對象轉換數據傳輸層DTO utils.TypeConverter import cn.temp.tempbeans.api.dto.ValidDTO; import cn.temp.tempbeans.po

帅炸了的Chester 2020-07-05 20:36:12

反射的基本使用實例

package com.franky.reflex; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.refl

franky814 2020-07-05 19:52:34

java註解與反射

註解與反射 **本文學自b站狂神：b站狂神–註解與反射篇** 看本文前建議看下JVM篇（對類加載器的詳細說明）：JVM學習 一、什麼是註解 Annotation是從JDK5.0開始引入的新技術. Annotation的作用

Inmaturity_7 2020-07-05 11:50:12

反射 ---基礎

反射是在只知道類的名字和路徑的情況下，通過反射獲取類中的屬性，構造器，方法，並創建該類的對象，使用其中的方法。 反射可以分爲 步：創建字符串（內容爲類的路徑）———- String s=”com.reflection.

一日立三金 2020-07-05 10:56:20

Junit測試類、註解、元註解個人小結

第一大塊 Junit測試類、註解、元註解 一、Junit測試類 a.必須部分，在前面加上@Test註解，就可以進行單獨測試了 b.Junit測試類常用註解 @Before 初始化，自動執行 @Test 測試段語句 @Aft

不_yu 2020-07-05 07:46:48

day26【反射、註解】

第1章 類加載器(ClassLoader) 1.1概述(瞭解) 類加載器： 負責將.class文件加載到內存中，併爲之生成對應的Class對象，也就是字節碼文件對象。 問題：我們平時書寫在idea中的Java程序是如何運行的呢？

娃娃 哈哈 2020-07-05 03:05:51