這篇文章主要講解了“Java中的反射有什么用途”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java中的反射有什么用途”吧！

我們提供的服務有：網站建設、網站設計、微信公眾號開發(fā)、網站優(yōu)化、網站認證、延長ssl等。為上千企事業(yè)單位解決了網站和推廣的問題。提供周到的售前咨詢和貼心的售后服務，是有科學管理、有技術的延長網站制作公司

回顧：什么是反射？

反射(Reflection)是Java 程序開發(fā)語言的特征之一，它允許運行中的 Java 程序獲取自身的信息，并且可以操作類或對象的內部屬性。
Oracle官方對反射的解釋是

Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts, within security restrictions.

The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class. It also allows programs to suppress default reflective access control.

?簡而言之，通過反射，我們可以在運行時獲得程序或程序集中每一個類型的成員和成員的信息。

程序中一般的對象的類型都是在編譯期就確定下來的，而Java反射機制可以動態(tài)地創(chuàng)建對象并調用其屬性，這樣的對象的類型在編譯期是未知的。所以我們可以通過反射機制直接創(chuàng)建對象，即使這個對象的類型在編譯期是未知的。

?反射的核心是JVM在運行時才動態(tài)加載類或調用方法/訪問屬性，它不需要事先（寫代碼的時候或編譯期）知道運行對象是誰。

Java反射框架主要提供以下功能：

1.在運行時判斷任意一個對象所屬的類；

2.在運行時構造任意一個類的對象；

3.在運行時判斷任意一個類所具有的成員變量和方法（通過反射甚至可以調用private方法）；

4.在運行時調用任意一個對象的方法

重點：是運行時而不是編譯時

反射的主要用途

?很多人都認為反射在實際的Java開發(fā)應用中并不廣泛，其實不然。

?當我們在使用IDE(如Eclipse，IDEA)時，當我們輸入一個對象或類并想調用它的屬性或方法時，一按點號，編譯器就會自動列出它的屬性或方法，這里就會用到反射。

?反射最重要的用途就是開發(fā)各種通用框架。

?很多框架（比如Spring）都是配置化的（比如通過XML文件配置JavaBean,Action之類的），為了保證框架的通用性，它們可能需要根據配置文件加載不同的對象或類，調用不同的方法，這個時候就必須用到反射——運行時動態(tài)加載需要加載的對象。

?舉一個例子，在運用Struts 2框架的開發(fā)中我們一般會在struts.xml里去配置Action，比如：

<action name="login"
               class="org.ScZyhSoft.test.action.SimpleLoginAction"
               method="execute">
           <result>/shop/shop-index.jsp</result>
           <result name="error">login.jsp</result>
       </action>

配置文件與Action建立了一種映射關系，當View層發(fā)出請求時，請求會被StrutsPrepareAndExecuteFilter攔截，然后StrutsPrepareAndExecuteFilter會去動態(tài)地創(chuàng)建Action實例。

——比如我們請求login.action，那么StrutsPrepareAndExecuteFilter就會去解析struts.xml文件，檢索action中name為login的Action，并根據class屬性創(chuàng)建SimpleLoginAction實例，并用invoke方法來調用execute方法，這個過程離不開反射。

對與框架開發(fā)人員來說，反射雖小但作用非常大，它是各種容器實現的核心。而對于一般的開發(fā)者來說，不深入框架開發(fā)則用反射用的就會少一點，不過了解一下框架的底層機制有助于豐富自己的編程思想，也是很有益的。

反射的基礎：關于Class類

更多關于Class類和Object類的原理和介紹請見上一節(jié)

1、Class是一個類，一個描述類的類（也就是描述類本身），封裝了描述方法的Method，描述字段的Filed，描述構造器的Constructor等屬性

2、對象照鏡子后（反射）可以得到的信息：某個類的數據成員名、方法和構造器、某個類到底實現了哪些接口。

3、對于每個類而言，JRE 都為其保留一個不變的 Class 類型的對象。一個Class對象包含了特定某個類的有關信息。

4、Class 對象只能由系統建立對象

5、一個類在 JVM 中只會有一個Class實例

//總結一下就是，JDK有一個類叫做Class，這個類用來封裝所有Java類型，包括這些類的所有信息，JVM中類信息是放在方法區(qū)的。
//所有類在加載后，JVM會為其在堆中創(chuàng)建一個Class<類名稱>的對象，并且每個類只會有一個Class對象，這個類的所有對象都要通過Class<類名稱>來進行實例化。
//上面說的是JVM進行實例化的原理，當然實際上在Java寫代碼時只需要用 類名稱就可以進行實例化了。
public final class Class<T> implements java.io.Serializable,
                          GenericDeclaration,
                          Type,
                          AnnotatedElement {
虛擬機會保持唯一一
            //通過類名.class獲得唯一的Class對象。
            Class<UserBean> cls = UserBean.class;
            //通過integer.TYPEl來獲取Class對象
            Class<Integer> inti = Integer.TYPE;
          //接口本質也是一個類，一樣可以通過.class獲取
            Class<User> userClass = User.class;

JAVA反射機制是在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態(tài)獲取的信息以及動態(tài)調用對象的方法的功能稱為java語言的反射機制。

要想解剖一個類,必須先要獲取到該類的字節(jié)碼文件對象。而解剖使用的就是Class類中的方法.所以先要獲取到每一個字節(jié)碼文件對應的Class類型的對象.

以上的總結就是什么是反射
反射就是把java類中的各種成分映射成一個個的Java對象
例如：一個類有：成員變量、方法、構造方法、包等等信息，利用反射技術可以對一個類進行解剖，把個個組成部分映射成一個個對象。（其實：一個類中這些成員方法、構造方法、在加入類中都有一個類來描述）
如圖是類的正常加載過程：反射的原理在與class對象。
熟悉一下加載的時候：Class對象的由來是將class文件讀入內存，并為之創(chuàng)建一個Class對象。

Java為什么需要反射？反射要解決什么問題？

Java中編譯類型有兩種：

靜態(tài)編譯：在編譯時確定類型，綁定對象即通過。
動態(tài)編譯：運行時確定類型，綁定對象。動態(tài)編譯最大限度地發(fā)揮了Java的靈活性，體現了多態(tài)的應用，可以減低類之間的耦合性。
Java反射是Java被視為動態(tài)（或準動態(tài)）語言的一個關鍵性質。這個機制允許程序在運行時透過Reflection APIs取得任何一個已知名稱的class的內部信息，包括其modifiers（諸如public、static等）、superclass（例如Object）、實現之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于運行時改變fields內容或喚起methods。

Reflection可以在運行時加載、探知、使用編譯期間完全未知的classes。即Java程序可以加載一個運行時才得知名稱的class，獲取其完整構造，并生成其對象實體、或對其fields設值、或喚起其methods。

反射（reflection）允許靜態(tài)語言在運行時（runtime）檢查、修改程序的結構與行為。
在靜態(tài)語言中，使用一個變量時，必須知道它的類型。在Java中，變量的類型信息在編譯時都保存到了class文件中，這樣在運行時才能保證準確無誤；換句話說，程序在運行時的行為都是固定的。如果想在運行時改變，就需要反射這東西了。

實現Java反射機制的類都位于java.lang.reflect包中：

Class類：代表一個類
Field類：代表類的成員變量（類的屬性）
Method類：代表類的方法
Constructor類：代表類的構造方法
Array類：提供了動態(tài)創(chuàng)建數組，以及訪問數組的元素的靜態(tài)方法
一句話概括就是使用反射可以賦予jvm動態(tài)編譯的能力，否則類的元數據信息只能用靜態(tài)編譯的方式實現，例如熱加載，Tomcat的classloader等等都沒法支持。

反射的基本運用

上面我們提到了反射可以用于判斷任意對象所屬的類，獲得Class對象，構造任意一個對象以及調用一個對象。這里我們介紹一下基本反射功能的實現(反射相關的類一般都在java.lang.relfect包里)。

1、獲得Class對象方法有三種

(1)使用Class類的forName靜態(tài)方法:

 public static Class<?> forName(String className)
```
在JDBC開發(fā)中常用此方法加載數據庫驅動:
要使用全類名來加載這個類，一般數據庫驅動的配置信息會寫在配置文件中。加載這個驅動前要先導入jar包
```java
 Class.forName(driver);

(2)直接獲取某一個對象的class，比如:

//Class<?>是一個泛型表示，用于獲取一個類的類型。
Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

(3)調用某個對象的getClass()方法,比如:

StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();

判斷是否為某個類的實例

一般地，我們用instanceof關鍵字來判斷是否為某個類的實例。同時我們也可以借助反射中Class對象的isInstance()方法來判斷是否為某個類的實例，它是一個Native方法：

==public native boolean isInstance(Object obj);==

創(chuàng)建實例

通過反射來生成對象主要有兩種方式。

（1）使用Class對象的newInstance()方法來創(chuàng)建Class對象對應類的實例。

注意：利用newInstance創(chuàng)建對象：調用的類必須有無參的構造器

//Class<?>代表任何類的一個類對象。
//使用這個類對象可以為其他類進行實例化
//因為jvm加載類以后自動在堆區(qū)生成一個對應的*.Class對象
//該對象用于讓JVM對進行所有*對象實例化。
Class<?> c = String.class;
//Class<?> 中的 ? 是通配符，其實就是表示任意符合泛類定義條件的類，和直接使用 Class
//效果基本一致，但是這樣寫更加規(guī)范，在某些類型轉換時可以避免不必要的 unchecked 錯誤。
Object str = c.newInstance();

（2）先通過Class對象獲取指定的Constructor對象，再調用Constructor對象的newInstance()方法來創(chuàng)建實例。這種方法可以用指定的構造器構造類的實例。

//獲取String所對應的Class對象
Class<?> c = String.class;
//獲取String類帶一個String參數的構造器
Constructor constructor = c.getConstructor(String.class);
//根據構造器創(chuàng)建實例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

獲取方法

獲取某個Class對象的方法集合，主要有以下幾個方法：

getDeclaredMethods()方法返回類或接口聲明的所有方法，==包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法==。

public Method[] getDeclaredMethods() throws SecurityException

getMethods()方法返回某個類的所有公用（public）方法，==包括其繼承類的公用方法。==

public Method[] getMethods() throws SecurityException

getMethod方法返回一個特定的方法，其中第一個參數為方法名稱，后面的參數為方法的參數對應Class的對象

public Method getMethod(String name, Class<?>... parameterTypes)

只是這樣描述的話可能難以理解，我們用例子來理解這三個方法：
本文中的例子用到了以下這些類，用于反射的測試。

//注解類，可可用于表示方法，可以通過反射獲取注解的內容。
    //Java注解的實現是很多注框架實現注解配置的基礎
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Invoke {
}

userbean的父類personbean

public class PersonBean {
private String name;
int id;
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

}

接口user

public interface User {
    public void login ();
}

userBean實現user接口，繼承personbean

public class UserBean extends PersonBean implements User{
    @Override
    public void login() {
    }
    class B {
    }
    public String userName;
    protected int i;
    static int j;
    private int l;
    private long userId;
    public UserBean(String userName, long userId) {
        this.userName = userName;
        this.userId = userId;
    }
    public String getName() {
        return userName;
    }
    public long getId() {
        return userId;
    }
    @Invoke
    public static void staticMethod(String devName,int a) {
        System.out.printf("Hi %s, I'm a static method", devName);
    }
    @Invoke
    public void publicMethod() {
        System.out.println("I'm a public method");
    }
    @Invoke
    private void privateMethod() {
        System.out.println("I'm a private method");
    }
}

1 getMethods和getDeclaredMethods的區(qū)別

public class 動態(tài)加載類的反射 {
    public static void main(String[] args) {
        try {
            Class clazz = Class.forName("com.javase.反射.UserBean");
            for (Field field : clazz.getDeclaredFields()) {
//                field.setAccessible(true);
                System.out.println(field);
            }
            //getDeclaredMethod*()獲取的是類自身聲明的所有方法，包含public、protected和private方法。
            System.out.println("------共有方法------");
//        getDeclaredMethod*()獲取的是類自身聲明的所有方法，包含public、protected和private方法。
//            getMethod*()獲取的是類的所有共有方法，這就包括自身的所有public方法，和從基類繼承的、從接口實現的所有public方法。
            for (Method method : clazz.getMethods()) {
                String name = method.getName();
                System.out.println(name);
                //打印出了UserBean.java的所有方法以及父類的方法
            }
            System.out.println("------獨占方法------");
            for (Method method : clazz.getDeclaredMethods()) {
                String name = method.getName();
                System.out.println(name);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

2 打印一個類的所有方法及詳細信息：

public class 打印所有方法 {
    public static void main(String[] args) {
        Class userBeanClass = UserBean.class;
        Field[] fields = userBeanClass.getDeclaredFields();
        //注意，打印方法時無法得到局部變量的名稱，因為jvm只知道它的類型
        Method[] methods = userBeanClass.getDeclaredMethods();
        for (Method method : methods) {
            //依次獲得方法的修飾符，返回類型和名稱，外加方法中的參數
            String methodString = Modifier.toString(method.getModifiers()) + " " ; // private static
            methodString += method.getReturnType().getSimpleName() + " "; // void
            methodString += method.getName() + "("; // staticMethod
            Class[] parameters = method.getParameterTypes();
            Parameter[] p = method.getParameters();
            for (Class parameter : parameters) {
                methodString += parameter.getSimpleName() + " " ; // String
            }
            methodString += ")";
            System.out.println(methodString);
        }
        //注意方法只能獲取到其類型，拿不到變量名
/*        public String getName()
        public long getId()
        public static void staticMethod(String int )
        public void publicMethod()
        private void privateMethod()*/
    }
}

獲取構造器信息

獲取類構造器的用法與上述獲取方法的用法類似。主要是通過Class類的getConstructor方法得到Constructor類的一個實例，而Constructor類有一個newInstance方法可以創(chuàng)建一個對象實例:

public class 打印構造方法 {
    public static void main(String[] args) {
        // constructors
        Class<?> clazz = UserBean.class;
        Class userBeanClass = UserBean.class;
        //獲得所有的構造方法
        Constructor[] constructors = userBeanClass.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            String s = Modifier.toString(constructor.getModifiers()) + " ";
            s += constructor.getName() + "(";
            //構造方法的參數類型
            Class[] parameters = constructor.getParameterTypes();
            for (Class parameter : parameters) {
                s += parameter.getSimpleName() + ", ";
            }
            s += ")";
            System.out.println(s);
            //打印結果//public com.javase.反射.UserBean(String, long, )
        }
    }
}

獲取類的成員變量（字段）信息

主要是這幾個方法，在此不再贅述：

getFiled: 訪問公有的成員變量
getDeclaredField：所有已聲明的成員變量。但不能得到其父類的成員變量
getFileds和getDeclaredFields用法同上（參照Method）

public class 打印成員變量 {
    public static void main(String[] args) {
        Class userBeanClass = UserBean.class;
        //獲得該類的所有成員變量，包括static private
        Field[] fields = userBeanClass.getDeclaredFields();
        for(Field field : fields) {
            //private屬性即使不用下面這個語句也可以訪問
//            field.setAccessible(true);
            //因為類的私有域在反射中默認可訪問，所以flag默認為true。
            String fieldString = "";
            fieldString += Modifier.toString(field.getModifiers()) + " "; // `private`
            fieldString += field.getType().getSimpleName() + " "; // `String`
            fieldString += field.getName(); // `userName`
            fieldString += ";";
            System.out.println(fieldString);
            //打印結果
//            public String userName;
//            protected int i;
//            static int j;
//            private int l;
//            private long userId;
        }
    }
}

調用方法

當我們從類中獲取了一個方法后，我們就可以用invoke()方法來調用這個方法。invoke方法的原型為:

public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
public class 使用反射調用方法 {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, InstantiationException, NoSuchMethodException {
        Class userBeanClass = UserBean.class;
        //獲取該類所有的方法，包括靜態(tài)方法，實例方法。
        //此處也包括了私有方法，只不過私有方法在用invoke訪問之前要設置訪問權限
        //也就是使用setAccessible使方法可訪問，否則會拋出異常
//       // IllegalAccessException的解釋是
//        * An IllegalAccessException is thrown when an application tries
// * to reflectively create an instance (other than an array),
// * set or get a field, or invoke a method, but the currently
// * executing method does not have access to the definition of
// * the specified class, field, method or constructor.
//        getDeclaredMethod*()獲取的是類自身聲明的所有方法，包含public、protected和private方法。
//            getMethod*()獲取的是類的所有共有方法，這就包括自身的所有public方法，和從基類繼承的、從接口實現的所有public方法。
        //就是說，當這個類，域或者方法被設為私有訪問，使用反射調用但是卻沒有權限時會拋出異常。
        Method[] methods = userBeanClass.getDeclaredMethods(); // 獲取所有成員方法
        for (Method method : methods) {
            //反射可以獲取方法上的注解，通過注解來進行判斷
            if (method.isAnnotationPresent(Invoke.class)) { // 判斷是否被 @Invoke 修飾
                //判斷方法的修飾符是是static
                if (Modifier.isStatic(method.getModifiers())) { // 如果是 static 方法
                    //反射調用該方法
                    //類方法可以直接調用，不必先實例化
                    method.invoke(null, "wingjay",2); // 直接調用，并傳入需要的參數 devName
                } else {
                    //如果不是類方法，需要先獲得一個實例再調用方法
                    //傳入構造方法需要的變量類型
                    Class[] params = {String.class, long.class};
                    //獲取該類指定類型的構造方法
                    //如果沒有這種類型的方法會報錯
                    Constructor constructor = userBeanClass.getDeclaredConstructor(params); // 獲取參數格式為 String,long 的構造函數
                    //通過構造方法的實例來進行實例化
                    Object userBean = constructor.newInstance("wingjay", 11); // 利用構造函數進行實例化，得到 Object
                    if (Modifier.isPrivate(method.getModifiers())) {
                        method.setAccessible(true); // 如果是 private 的方法，需要獲取其調用權限
//                        Set the {@code accessible} flag for this object to
//     * the indicated boolean value.  A value of {@code true} indicates that
//     * the reflected object should suppress Java language access
//     * checking when it is used.  A value of {@code false} indicates
//                                * that the reflected object should enforce Java language access checks.
                        //通過該方法可以設置其可見或者不可見，不僅可以用于方法
                        //后面例子會介紹將其用于成員變量
                                            //打印結果
//            I'm a public method
// Hi wingjay, I'm a static methodI'm a private method
                    }
                    method.invoke(userBean); // 調用 method，無須參數
                }
            }
        }
    }
}

利用反射創(chuàng)建數組

數組在Java里是比較特殊的一種類型，它可以賦值給一個Object Reference。下面我們看一看利用反射創(chuàng)建數組的例子：

public class 用反射創(chuàng)建數組 {
    public static void main(String[] args) {
        Class<?> cls = null;
        try {
            cls = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Object array = Array.newInstance(cls,25);
        //往數組里添加內容
        Array.set(array,0,"hello");
        Array.set(array,1,"Java");
        Array.set(array,2,"fuck");
        Array.set(array,3,"Scala");
        Array.set(array,4,"Clojure");
        //獲取某一項的內容
        System.out.println(Array.get(array,3));
        //Scala
    }
}

其中的Array類為java.lang.reflect.Array類。我們通過Array.newInstance()創(chuàng)建數組對象，它的原型是:

public static Object newInstance(Class<?> componentType, int length)
        throws NegativeArraySizeException {
        return newArray(componentType, length);
    }

而newArray()方法是一個Native方法，它在Hotspot JVM里的具體實現我們后邊再研究，這里先把源碼貼出來

private static native Object newArray(Class<?> componentType, int length)
        throws NegativeArraySizeException;

Java反射常見面試題

什么是反射？

反射是在運行狀態(tài)中，對于任意一個類，都能夠知道這個類的所有屬性和方法；對于任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態(tài)獲取的信息以及動態(tài)調用對象的方法的功能稱為 Java 語言的反射機制。

哪里用到反射機制？

JDBC中，利用反射動態(tài)加載了數據庫驅動程序。
Web服務器中利用反射調用了Sevlet的服務方法。
Eclispe等開發(fā)工具利用反射動態(tài)刨析對象的類型與結構，動態(tài)提示對象的屬性和方法。
很多框架都用到反射機制，注入屬性，調用方法，如Spring。

什么叫對象序列化，什么是反序列化，實現對象序列化需要做哪些工作？

對象序列化，將對象中的數據編碼為字節(jié)序列的過程。
反序列化；將對象的編碼字節(jié)重新反向解碼為對象的過程。
JAVA提供了API實現了對象的序列化和反序列化的功能，使用這些API時需要遵守如下約定：
被序列化的對象類型需要實現序列化接口，此接口是標志接口，沒有聲明任何的抽象方法，JAVA編譯器識別這個接口，自動的為這個類添加序列化和反序列化方法。
為了保持序列化過程的穩(wěn)定，建議在類中添加序列化版本號。
不想讓字段放在硬盤上就加transient
以下情況需要使用 Java 序列化：
想把的內存中的對象狀態(tài)保存到一個文件中或者數據庫中時候；
想用套接字在網絡上傳送對象的時候；
想通過RMI（遠程方法調用）傳輸對象的時候。

反射機制的優(yōu)缺點？

優(yōu)點：可以動態(tài)執(zhí)行，在運行期間根據業(yè)務功能動態(tài)執(zhí)行方法、訪問屬性，最大限度發(fā)揮了java的靈活性。
缺點：對性能有影響，這類操作總是慢于直接執(zhí)行java代碼。

動態(tài)代理是什么？有哪些應用？

動態(tài)代理是運行時動態(tài)生成代理類。
動態(tài)代理的應用有 Spring AOP數據查詢、測試框架的后端 mock、rpc，Java注解對象獲取等。

怎么實現動態(tài)代理？

JDK 原生動態(tài)代理和 cglib 動態(tài)代理。
JDK 原生動態(tài)代理是基于接口實現的，而 cglib 是基于繼承當前類的子類實現的。

Java反射機制的作用

在運行時判斷任意一個對象所屬的類
在運行時構造任意一個類的對象
在運行時判斷任意一個類所具有的成員變量和方法
在運行時調用任意一個對象的方法

如何使用Java的反射?

通過一個全限類名創(chuàng)建一個對象

Class.forName(“全限類名”); 例如：com.MySQL.jdbc.Driver Driver類已經被加載到 jvm中，并且完成了類的初始化工作就行了
類名.class; 獲取Class<？> clz 對象
對象.getClass();

獲取構造器對象，通過構造器new出一個對象

Clazz.getConstructor([String.class]);
Con.newInstance([參數]);
通過class對象創(chuàng)建一個實例對象（就相當與new類名（）無參構造器)
Cls.newInstance();

通過class對象獲得一個屬性對象

Field c=cls.getFields()：獲得某個類的所有的公共（public）的字段，包括父類中的字段。
Field c=cls.getDeclaredFields()：獲得某個類的所有聲明的字段，即包括public、private和proteced，但是不包括父類的聲明字段

通過class對象獲得一個方法對象

Cls.getMethod(“方法名”,class……parameaType);（只能獲取公共的）
Cls.getDeclareMethod(“方法名”);（獲取任意修飾的方法，不能執(zhí)行私有）
M.setAccessible(true);（讓私有的方法可以執(zhí)行）
讓方法執(zhí)行
1）. Method.invoke(obj實例對象,obj可變參數);——-（是有返回值的）

感謝各位的閱讀，以上就是“Java中的反射有什么用途”的內容了，經過本文的學習后，相信大家對Java中的反射有什么用途這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是創(chuàng)新互聯，小編將為大家推送更多相關知識點的文章，歡迎關注！

標題名稱：Java中的反射有什么用途
標題來源：http://jinyejixie.com/article36/psehsg.html

成都網站建設公司_創(chuàng)新互聯，為您提供標簽優(yōu)化、用戶體驗、網站制作、建站公司、網站設計公司、軟件開發(fā)

廣告

聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯