java反射機制的講解（java反射機制詳解）

本文目錄一覽：

• 1、如何理解Java反射機制
• 2、java中的反射機制是什麼？有什麼作用呢？求解，謝謝。
• 3、Java裏面反射的原理是什麼？
• 4、什麼是java的反射?
• 5、什麼是反射？什麼Java反射？

如何理解Java反射機制

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

JAVA反射（放射）機制：「程序運行時，允許改變程序結構或變量類型，這種語言稱為動態語言」。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#不是動態語言。但是JAVA有着一個非常突出的動態相關機制：Reflection，用在Java身上指的是我們可以於運行時加載、探知、使用編譯期間完全未知的classes。換句話說，Java程序可以加載一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其methods！

java中的反射機制是什麼？有什麼作用呢？求解，謝謝。

Java反射機制詳解

1. 反射機制是什麼

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

2. 反射機制能做什麼

反射機制主要提供了以下功能：

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

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

在運行時判斷任意一個類所具有的成員變量和方法；

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

生成動態代理。

3. 反射機制的相關API

通過一個對象獲得完整的包名和類名

package net.xsoftlab.baike;

public class TestReflect {

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

        TestReflect testReflect = new TestReflect();

        System.out.println(testReflect.getClass().getName());

        // 結果 net.xsoftlab.baike.TestReflect

    }

}

實例化Class類對象

package net.xsoftlab.baike;

public class TestReflect {

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

        Class? class1 = null;

        Class? class2 = null;

        Class? class3 = null;

        // 一般採用這種形式

        class1 = Class.forName(“net.xsoftlab.baike.TestReflect”);

        class2 = new TestReflect().getClass();

        class3 = TestReflect.class;

        System.out.println(“類名稱   ” + class1.getName());

        System.out.println(“類名稱   ” + class2.getName());

        System.out.println(“類名稱   ” + class3.getName());

    }

}

獲取一個對象的父類與實現的接口

package net.xsoftlab.baike;

import java.io.Serializable;

public class TestReflect implements Serializable {

    private static final long serialVersionUID = -2862585049955236662L;

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

        Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);

        // 取得父類

        Class? parentClass = clazz.getSuperclass();

        System.out.println(“clazz的父類為：” + parentClass.getName());

        // clazz的父類為： java.lang.Object

        // 獲取所有的接口

        Class? intes[] = clazz.getInterfaces();

        System.out.println(“clazz實現的接口有：”);

        for (int i = 0; i  intes.length; i++) {

            System.out.println((i + 1) + “：” + intes[i].getName());

        }

        // clazz實現的接口有：

        // 1：java.io.Serializable

    }

}

獲取某個類中的全部構造函數 – 詳見下例

通過反射機制實例化一個類的對象

package net.xsoftlab.baike;

import java.lang.reflect.Constructor;

public class TestReflect {

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

        Class? class1 = null;

        class1 = Class.forName(“net.xsoftlab.baike.User”);

        // 第一種方法，實例化默認構造方法，調用set賦值

        User user = (User) class1.newInstance();

        user.setAge(20);

        user.setName(“Rollen”);

        System.out.println(user);

        // 結果 User [age=20, name=Rollen]

        // 第二種方法 取得全部的構造函數 使用構造函數賦值

        Constructor? cons[] = class1.getConstructors();

        // 查看每個構造方法需要的參數

        for (int i = 0; i  cons.length; i++) {

            Class? clazzs[] = cons[i].getParameterTypes();

            System.out.print(“cons[” + i + “] (“);

            for (int j = 0; j  clazzs.length; j++) {

                if (j == clazzs.length – 1)

                    System.out.print(clazzs[j].getName());

                else

                    System.out.print(clazzs[j].getName() + “,”);

            }

            System.out.println(“)”);

        }

        // 結果

        // cons[0] (java.lang.String)

        // cons[1] (int,java.lang.String)

        // cons[2] ()

        user = (User) cons[0].newInstance(“Rollen”);

        System.out.println(user);

        // 結果 User [age=0, name=Rollen]

        user = (User) cons[1].newInstance(20, “Rollen”);

        System.out.println(user);

        // 結果 User [age=20, name=Rollen]

    }

}

class User {

    private int age;

    private String name;

    public User() {

        super();

    }

    public User(String name) {

        super();

        this.name = name;

    }

    public User(int age, String name) {

        super();

        this.age = age;

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return “User [age=” + age + “, name=” + name + “]”;

    }

}

獲取某個類的全部屬性

package net.xsoftlab.baike;

import java.io.Serializable;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

public class TestReflect implements Serializable {

    private static final long serialVersionUID = -2862585049955236662L;

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

        Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);

        System.out.println(“===============本類屬性===============”);

        // 取得本類的全部屬性

        Field[] field = clazz.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 = clazz.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() + “;”);

        }

    }

}

通過反射機制調用某個類的方法

package net.xsoftlab.baike;

import java.lang.reflect.Method;

public class TestReflect {

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

        Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);

        // 調用TestReflect類中的reflect1方法

        Method method = clazz.getMethod(“reflect1”);

        method.invoke(clazz.newInstance());

        // Java 反射機制 – 調用某個類的方法1.

        // 調用TestReflect的reflect2方法

        method = clazz.getMethod(“reflect2”, int.class, String.class);

        method.invoke(clazz.newInstance(), 20, “張三”);

        // Java 反射機制 – 調用某個類的方法2.

        // age – 20. name – 張三

    }

    public void reflect1() {

        System.out.println(“Java 反射機制 – 調用某個類的方法1.”);

    }

    public void reflect2(int age, String name) {

        System.out.println(“Java 反射機制 – 調用某個類的方法2.”);

        System.out.println(“age – ” + age + “. name – ” + name);

    }

}

通過反射機制操作某個類的屬性

package net.xsoftlab.baike;

import java.lang.reflect.Field;

public class TestReflect {

    private String proprety = null;

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

        Class? clazz = Class.forName(“net.xsoftlab.baike.TestReflect”);

        Object obj = clazz.newInstance();

        // 可以直接對 private 的屬性賦值

        Field field = clazz.getDeclaredField(“proprety”);

        field.setAccessible(true);

        field.set(obj, “Java反射機制”);

        System.out.println(field.get(obj));

    }

}

4. 反射機制的應用實例

在泛型為Integer的ArrayList中存放一個String類型的對象。

package net.xsoftlab.baike;

import java.lang.reflect.Method;

import java.util.ArrayList;

public class TestReflect {

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

        ArrayListInteger list = new ArrayListInteger();

        Method method = list.getClass().getMethod(“add”, Object.class);

        method.invoke(list, “Java反射機制實例。”);

        System.out.println(list.get(0));

    }

}

通過反射取得並修改數組的信息

package net.xsoftlab.baike;

import java.lang.reflect.Array;

public class TestReflect {

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

        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));

    }

}

將反射機制應用於工廠模式

package net.xsoftlab.baike;

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;

    }

}

/**

 * 對於普通的工廠模式當我們在添加一個子類的時候，就需要對應的修改工廠類。 當我們添加很多的子類的時候，會很麻煩。

 * Java 工廠模式可以參考

 * 

 * 

 * 現在我們利用反射機制實現工廠模式，可以在不修改工廠類的情況下添加任意多個子類。

 * 

 * 但是有一點仍然很麻煩，就是需要知道完整的包名和類名，這裡可以使用properties配置文件來完成。

 * 

 * java 讀取 properties 配置文件 的方法可以參考

 * 

 * 

 * @author xsoftlab.net

 */

public class TestReflect {

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

        fruit f = Factory.getInstance(“net.xsoftlab.baike.Apple”);

        if (f != null) {

            f.eat();

        }

    }

}

我有一個微信公眾號，經常會分享一些Java技術相關的乾貨，還有一些學習資源。

如果你喜歡我的分享，可以用微信搜索「Java團長」或者「javatuanzhang」關注。

Java裏面反射的原理是什麼？

Java在編譯之後會生成一個class文件，反射通過位元組碼文件找到其類中的方法和屬性等。

通過反射，java可以動態的加載未知的外部配置對象，臨時生成位元組碼進行加載使用，使代碼更靈活，極大地提高應用的擴展性。

其實博客會有更加詳細的解釋。

什麼是java的反射?

Java反射指的是對於任何的一個java類，我們都可以通過反射獲取到這個類的所有屬性和方法(包含私有的屬性方法)，使用java反射我們也可以調用一個對象的任何方法。

我們知道Java是一門面向對象編程的語言，我們編程的時候，經常會將類的屬性進行封裝，然後提供public方法進行屬性的設置和獲取。類的屬性我們通常會設置成private的私有屬性，為的就是保護對象屬性不被隨意的修改和訪問。但是反射機制卻恰恰相反，通過反射，我們可以獲取到這些被保護的屬性和方法，並且可以修改和訪問他們。

在java中我們可以使用object對象的getClass();方法獲得Class的對象classObject;語法格式為 Class classObject = object.getClass() ;可以根據Class對象的方法獲取object對象的相關屬性和方法;

獲取object對象的名字可以使用 classObject.getName();獲取類的名稱，獲取到的結果包含包的名稱;

獲取object對象的包名稱，可以使用classObject.getPackage();獲取包的名稱;

獲取object對象的所有public屬性，可以使用classObject.getFields();方法，返回列表是屬性類Field[]對象列表;

獲取object對象所有屬性,可以使用classObject.getDeclaredFields();方法，返回的是所有屬性列表(包含private屬性);

獲取object對象某個特定的屬性,可以使用classObject.getField( fieldName );可以根據屬性名稱獲取屬性類的對象;

獲取object對象private屬性，可以使用classObject.getDeclaredField( fieldName );根據屬性名獲取屬性對象信息;

獲取object對象public方法，使用classObject.getMethods();可以獲取到方法類Method[]對象列表;

獲取object對象某個特定的public方法，使用classObject.getMethod( funName , Class… parameterTypes);根據方法名和方法參數類型列表，可以獲取到方法類的對象;

獲取object對象所有方法(包含private方法);使用classObject.getDeclaredMethods();可以獲取所有的方法對象列表;

獲取object對象某個特定方法(包含private方法)，使用classObject.getDeclaredMethod ( funName, Class… parameterTypes );根據方法名和方法參數類型列表，可以獲取到類的特定方法(包含private方法);

獲取object對象類中所有的public構造方法，可以使用classObject.getConstructors(); 獲取到構造類Constructor的對象列表;

獲取object對象類中某個特定的構造方法，可以使用classObject.getConstructor( Class… parameterTypes ); 根據參數類型列表，獲取指定的構造函數對象;

獲取object對象類中所有的構造方法(包含private)，可以使用classObject.getDeclaredConstructors(); 獲取到構造類Constructor的對象列表;

獲取object對象類中某個特定的構造方法(包含private)，可以使用classObject.getDeclaredConstructor( Class… parameterTypes ); 根據參數類型列表，獲取指定的構造函數對象;

什麼是反射？什麼Java反射？

java反射是什麼意思呢？下面帶大家了解一下。

JAVA反射是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。反射是一種強大的工具，能夠創建靈活的代碼，可以使代碼在運行時裝配，無需在組件之間進行源代表鏈接。

JAVA反射機制是在運行狀態中，知道所有屬性和方法，對於任意一個對象，能夠調用它的方法和屬性，這種動態獲取的信息以及動態調用對象的方法的功能的反射機制。

反射適合用在哪

首先我們先思考一個問題，反射適合使用在哪裡呢？從功能上看，反射似乎無所不能，幾乎所有的類，所有的屬性、方法、構造我們都能使用，但是我們細細思考一下，在實際開發中，並不是所有場景都需要使用反射獲取屬性或者方法進行操作，反而更多的使用實例.xxx方式操作，而當這些操作重複次數較多的時候，我們往往會考慮優化代碼，減少代碼冗餘，提高復用，比如實體構建賦值等操作，這個時候往往是我們最需要復用的地方，所以我們可以大體認為反射主要使用在實體操作過程中。而在一般操作數據的過程中，我們的實體一般都是知道並且依賴於對應的數據類型的，比如:

1.根據類型new的方式創建對象

2.根據類型定義變量，類型可能是基本類型也可能是引用類型、類或者接口

3.將對應類型的對象傳遞給方法

4.根據類型訪問對象的屬性，調用方法等操作

以上這些操作都是數據操作的過程中最常見也是最難復用優化的地方，而如果這裡的操作使用反射則可以實現動態的操作不同的類型的實例，通過調用反射入口類Class，獲取對應的屬性、構造、方法完成對應的操作