JavaSE學習筆記 - 反射技術

阿新 • • 發佈：2020-08-27

概述

反射是一種強大的工具，可以用來編寫能夠動態操縱 Java 程式碼的程式，通過反射機制我們可以操作位元組碼檔案。反射機制將類的各個部分封裝成了物件，在程式執行的過程中我們可以操作這些物件(在操作一個類物件的時候我們可以操作其方法成員變數等)。這樣可以使得程式解耦，提高了程式的可擴充套件性。

Java 程式碼的三個階段

原始碼階段：編寫類檔案，然後新增成員變數，成員方法等，程式碼編譯後生成位元組碼檔案，此時程式碼還未被載入進記憶體。
Class 類物件階段：Class 類物件使用類載入器將位元組碼檔案載入進記憶體，此時記憶體中就會產生一個唯一的 Class 類物件來標識這個類中的各項資訊，Class 類物件中又包含了描述成員變數的 Field 物件、描述構造方法的 Constructor 物件和描述成員方法的 Method 物件。

執行時階段：new 一個新的類物件。

Class

在程式執行的時候，系統始終為所有的物件維護一個執行時的型別標識，這個資訊會跟蹤每一個物件所屬的類，我們使用 Java 中的 Class 類就可以訪問這些被記錄的資訊。

獲取 Class 物件的三種方式

Class.forName("全類名")：將位元組碼檔案載入進記憶體，配置檔案常用

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Class cls = Class.forName("java.lang.String");
        System.out.println(cls);//class java.lang.String
    }
}

類名.class：常用於引數的傳遞

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Class cls = Class.forName("java.lang.String");
        Class cls1 = String.class;
        System.out.println(cls.hashCode());//460141958
        System.out.println(cls1);//class java.lang.String
    }
}

物件.getClass()：常用於獲取物件位元組碼

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Class cls = Class.forName("java.lang.String");
        Class cls1 = String.class;
        String str = "";
        Class cls2 = str.getClass();
        //位元組碼檔案在記憶體中只被載入一次
        //不管使用什麼方式獲取到的Class物件都是同一個
        System.out.println(cls.hashCode());//460141958
        System.out.println(cls1.hashCode());//460141958
        System.out.println(cls2);//class java.lang.String
    }
}

Class 類常用 API

獲取 public 修飾的成員變數

//獲取 public 修飾的成員變數
public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class cls = Class.forName("java.lang.String");
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }

        Field field = cls.getField("CASE_INSENSITIVE_ORDER");
        System.out.println(field.getName());
    }
}


//獲取所有的成員變數
public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class cls = Class.forName("java.lang.String");
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }

        Field field = cls.getDeclaredField("hash");
        System.out.println(field.getName());
    }
}

獲取建構函式

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        //得到所有公共的建構函式物件
        Constructor[] constructors = cls.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        //得到特定的公共建構函式物件
        Constructor constructor = cls.getConstructor(String.class);
        System.out.println(constructor);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        //得到所有的建構函式物件
        Constructor[] constructors = cls.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        //得到特定的建構函式物件
        Constructor constructor = cls.getDeclaredConstructor(String.class);
        System.out.println(constructor);
    }
}

獲取成員方法

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        //獲取所有公共的成員方法
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        //獲取特定的公共的成員方法
        System.out.println("-------");
        Method method = cls.getMethod("toLowerCase", Locale.class);
        System.out.println(method);
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        //獲取所有的成員方法
        Method[] methods = cls.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        //獲取特定的成員方法
        System.out.println("-------");
        Method method = cls.getDeclaredMethod("lastIndexOfSupplementary", int.class, int.class);
        System.out.println(method);
    }
}

有關 Class 類的 API

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        System.out.println(cls.getName());//java.lang.String
        System.out.println(cls.getSimpleName());//String

        //獲取父類
        Class superclass = cls.getSuperclass();
        System.out.println(superclass);//class java.lang.Object
        System.out.println(superclass.isInterface());//false

        //獲取包物件
        Package aPackage = cls.getPackage();
        System.out.println(aPackage.getName());//java.lang

    }
}

Constructor

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        //得到所有的建構函式物件
        Constructor[] constructors = cls.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
            //方法名
            System.out.println(constructor.getName());
            //修飾符
            System.out.println(Modifier.toString(constructor.getModifiers()));
            //引數型別
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.print(parameterType.getName() + " ");
            }
            System.out.println();
            System.out.println("-------------------------------------");
        }
    }
}


//建立物件
public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = String.class;
        String str = (String) cls.newInstance();
    }
}

Field

public class Main {
    public static void main(String[] args) throws Exception {
        String str = "1111";
        Class cls = Class.forName("java.lang.String");
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
            System.out.println(Modifier.toString(field.getModifiers()));
            System.out.println(field.getType().getSimpleName());
            System.out.println(field.getName());
            //System.out.println(field.get(str));
            System.out.println("-----------------------------------------------");
        }

    }
}
//為物件的成員變數設定值
public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = String.class;
        String str = (String) cls.newInstance();
        Field field = cls.getDeclaredField("value");
        //不是公共的成員變數是需要暴力反射,預設只能修改非公共成員變數
        field.setAccessible(true);
        System.out.println(field);
        System.out.println(field.get(str));//[C@4554617c
        System.out.println(str);//
        field.set(str, new char[]{'1', '1'});
        System.out.println(field.get(str));//[C@74a14482
        System.out.println(str);//11
    }
}

Method

public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("java.lang.String");

        //獲取所有的成員方法
        Method[] methods = cls.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
            System.out.println(Modifier.toString(method.getModifiers()));
            System.out.println(method.getReturnType().getSimpleName());
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println(parameterType.getSimpleName());
            }
            //是否有可變引數
            System.out.println(method.isVarArgs());
            System.out.println(method.getName());
            System.out.println("-------------------------");
        }
    }
}

//執行類方法
public class Main {
    public static void main(String[] args) throws Exception {
        Class cls = String.class;
        String str = (String) cls.newInstance();
        Field field = cls.getDeclaredField("value");
        field.setAccessible(true);

        field.set(str, new char[]{'1', '1'});

        Method method = cls.getDeclaredMethod("length");
        System.out.println(method.invoke(str));

    }
}

配置檔案操作類

配置檔案

className = java.lang.String
methodName = length
fieldName = value

Properties + IO + 反射

public class Main {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();

        //方式一:利用當前類獲取流,配置檔案需要在src目錄下
        ClassLoader classLoader = Main.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        properties.load(is); //要記得關閉流

        //方式二:首先獲取檔案路徑,然後根據路徑建立輸入流
        //配置檔案需要在根路徑下
//        String path = Thread.currentThread().getContextClassLoader().getResource("pro.properties").getPath();
//        //System.out.println(path);
//        FileReader reader = new FileReader(path);
//        properties.load(reader);

        Class cls = Class.forName(properties.getProperty("className"));
        Object o = cls.newInstance();
        Field field = cls.getDeclaredField(properties.getProperty("fieldName"));
        field.setAccessible(true);
        field.set(o, new char[]{'a', 'b'});
        System.out.println(field.get(o));

        Method method = cls.getDeclaredMethod(properties.getProperty("methodName"));
        System.out.println(method.invoke(o));
    }
}

ResourceBundle + 反射

public class Main {
    public static void main(String[] args) throws Exception {
        //資源繫結器,配置檔案需要放在根路徑下
        ResourceBundle bundle = ResourceBundle.getBundle("pro");

        Class cls = Class.forName(bundle.getString("className"));
        Object o = cls.newInstance();
        Field field = cls.getDeclaredField(bundle.getString("fieldName"));
        field.setAccessible(true);
        field.set(o, new char[]{'a', 'b'});
        System.out.println(field.get(o));

        Method method = cls.getDeclaredMethod(bundle.getString("methodName"));
        System.out.println(method.invoke(o));
    }
}

反射方式反編譯類框架

配置檔案

className = java.util.ResourceBundle

測試程式碼

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        //資源繫結器,配置檔案需要放在根路徑下
        ResourceBundle bundle = ResourceBundle.getBundle("pro");

        Class<?> cls = Class.forName(bundle.getString("className"));
        Package aPackage = cls.getPackage();
        //包
        if (aPackage != null) System.out.println("package " + aPackage.getName());
        System.out.println();
        //修飾符
        System.out.print(Modifier.toString(cls.getModifiers()) + " ");
        //類名
        System.out.print(cls.getSimpleName() + " ");
        //父類
        Class<?> superclass = cls.getSuperclass();
        if (!superclass.equals(Object.class)) {
            System.out.print( "extends " + superclass.getSimpleName() + " ");
        }
        //介面
        Class<?>[] interfaces = cls.getInterfaces();
        StringBuilder _interfaces = new StringBuilder();
        if(interfaces.length == 0) {
            _interfaces.append("");
        } else {
            _interfaces.append(" implements ");
        }
        for (int i = 0; i < interfaces.length; i++) {
            _interfaces.append(interfaces[i].getSimpleName());
            if (i != interfaces.length - 1) {
                _interfaces.append(", ");
            } else {
                _interfaces.append(" ");
            }
        }
        System.out.println(_interfaces + "{");

        System.out.println();
        //獲取成員變數
        getDeclaredFields(cls);
        //獲取構造方法
        getDeclaredConstructors(cls);
        //獲取成員方法
        getMethods(cls);

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

    private static void getDeclaredFields(Class<?> cls) {
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            System.out.print("\t");
            //修飾符
            System.out.print(Modifier.toString(field.getModifiers()) + " ");
            //資料型別
            System.out.print(field.getType().getSimpleName() + " ");
            //變數名
            System.out.println(field.getName() + ";");
            //System.out.println(field);
            //System.out.println("----------------");
        }
        System.out.println();
    }

    private static void getDeclaredConstructors(Class<?> cls) {
        Constructor<?>[] constructors = cls.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            //修飾符
            System.out.print("\t");
            if (constructor.getModifiers() != 0)
                System.out.print(Modifier.toString(constructor.getModifiers()) + " ");
            //方法名
            System.out.print(cls.getSimpleName() + "(");
            //引數
            Class<?>[] typeParameters = constructor.getParameterTypes();
            StringBuilder _typeParameters = new StringBuilder();
            for (int i = 0; i < typeParameters.length; i++) {
                if (i != 0) {
                    _typeParameters.append(", ");
                }
                _typeParameters.append(typeParameters[i].getSimpleName());
            }
            System.out.println(_typeParameters + "){};");
            //System.out.println(constructor);
            //System.out.println("---------------------------");
        }
        System.out.println();
    }

    private static void getMethods(Class<?> cls) {
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.print("\t");
            //修飾符
            System.out.print(Modifier.toString(method.getModifiers()) + " ");
            //返回值
            System.out.print(method.getReturnType().getSimpleName() + " ");
            //方法名
            System.out.print(method.getName() + "(");
            //引數
            Class<?>[] parameterTypes = method.getParameterTypes();
            StringBuilder _parameterTypes = new StringBuilder();
            for (int i = 0; i < parameterTypes.length; i++) {
                if (i != 0) {
                    _parameterTypes.append(", ");
                }
                _parameterTypes.append(parameterTypes[i].getSimpleName());
            }
            System.out.println(_parameterTypes + "){};");
            //System.out.println(method);
            //System.out.println("------------------------");
        }
        System.out.println();
    }
}

JavaSE學習筆記 - 反射技術

概述反射是一種強大的工具，可以用來編寫能夠動態操縱 Java 程式碼的程式，通過反射機制我們可以操作位元組碼檔案。反射機制將類的各個部分封裝成了物件，在程式執行的過程中我們可以操作這些物件(在操作一個類物件

JavaSE學習筆記 - 面向物件基礎

面向物件面向物件特點：封裝性、繼承性、多型性、(抽象性) 面向物件：不關心具體的步驟，具體的步驟已經由某一個物件完成，考慮哪一個物件完成了這個事情，找到這個物件來做某一件事情。

JavaSE學習筆記 - Java基礎語法

Java語言特性簡單性：Java 中真正操作記憶體的是 Java 虛擬機器，Java 虛擬機器通過執行 Java 程式來操作記憶體，而 C++ 都是通過指標來操作記憶體，Java 程式中不能直接操作指標，所以在 Java 中不容易導致記憶體

JavaSE學習筆記 - Collection集合

集合是一種容器，可以用來儲存物件。在陣列中儲存物件是長度一旦確定是不能改變的，但是集合的長度是可變的。

JavaSE學習筆記 - 異常處理機制

程式在執行的過程中出現非正常的情況，最終導致 JVM 非正常停止。異常在 Java 中以類的形式存在，每一個異常類都可以建立物件，在產生異常的時候就是建立了一個異常類的物件，然後將異常物件丟擲。

JavaSE學習筆記 - 數字類、隨機數

BigInteger import java.math.BigInteger; public class Main { public static void main(String[] args) { //加

JavaSE學習筆記 - Object類、日期類

Object Object 類是 Java 中所有類的超類，Java 中每個類都是由 Object 這個類拓展而來的。可以使用 Object 型別的變數引用任何型別的物件。

JavaSE學習筆記 - I/O流詳解

I/O 概述 I/O流：對硬碟檔案進行讀寫，輸入流就是將硬碟檔案的內容讀入到記憶體中使用，輸出流就是將記憶體中的資料讀入到硬碟檔案中，以便於長期儲存。檔案是由字元或者位元組構成的，所以可以進行寫入和讀取。

JavaSE學習筆記 - Map集合

Map 繼承結構圖 Map Map 集合為雙列集合，集合中不能包含重複的鍵，但是值可以重複，並且每一個鍵只能對應一個值。

JavaSE學習筆記 - File類與遞迴

主要用於檔案和目錄的建立、刪除和查詢等操作，Java 把電腦中的檔案封裝成了 File 類，在編寫程式碼的時候我們可以使用 File 類來對檔案或者資料夾進行操作。

JavaSE學習筆記二

第一階段——模組二一、類的執行流程和記憶體分析當類被執行的時候，會載入到記憶體中的方法區。

JavaSE學習筆記（五）——類與物件

一、類和物件1.1面向物件與面向過程的區別 1．面向過程採用面向過程必須瞭解整個過程，每個步驟都有因果關係，每個因果關係都構成了一個步驟，多個步驟就構成了一個系統，因為存在因果關係每個步驟很難分

JavaSE學習筆記（四）——Java中的方法

一、Java中的方法需求：求整數10和整數3的乘積，然後在求整數2000和整數300的乘積。public class MethodTest01 {

JavaSE學習筆記（二）——變數和資料型別

一、Java中的變數1.1字面值的概念字面值是記憶體中的一塊空間，這塊空間存放有值，並且這個值是有型別的。如：在記憶體中的某個空間存放著100的值，型別是整型。在記憶體的另一個空間存放著true，代表真，

JavaSE學習筆記（一）——Java簡介與基礎

一、Java語言簡介1.1計算機語言的發展過程計算機語言發展主要分為三個階段：1．第一代：機器語言2．第二代：低階語言3．第三代：高階語言1.2Java發展簡史 1．Java 是一種程式開發語言，既然是一門語言，

JavaSE學習筆記02運算子、幫助文件生成與Scanner輸入

1. 運算子 1. 算術運算子：+，-，*，/，%，++，-- //二元運算子 int a = 10; int b = 20; int c = 25;

JavaSE學習筆記05面向物件程式設計01

面向物件程式設計01 java的核心思想就是OOP 面向過程&面向物件面向過程思想：

JavaSE學習筆記06面向物件程式設計02

面向物件程式設計02 1.封裝我們程式設計要求“高內聚，低耦合”。高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用

JavaSE學習筆記07面向物件程式設計03

面向物件程式設計03 1.static關鍵字補充 package com.oop.demo07; public class Student { private static int age;//靜態的變數

【JavaSE學習筆記03】介面

Chapter 6. 介面介面（interface）技術，主要用來描述類具有什麼功能，而並不給出每個功能的具體實現。一個類可以實現（implement）一個或多個介面，並在需要介面的地方，隨時使用實現了相應介面的物件。

JavaSE學習筆記 - 反射技術

概述

Class

獲取 Class 物件的三種方式

Class 類常用 API

Constructor

Field

Method

配置檔案操作類

反射方式反編譯類框架

相關推薦