java---類載入器和反射

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

類的載入

當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連線，初始化三步來實現對這個類進行初始化。

步驟：

1. 建立類的例項

2. 類的靜態變數，或者為靜態變數賦值

3. 類的靜態方法

4. 使用反射方式來強制建立某個類或介面對應的java.lang.Class物件

5. 初始化某個類的子類

6. 直接使用java.exe命令來執行某個主類

負責將.class檔案載入到記憶體中，併為之生成對應的Class物件。

獲取Class物件的三種方式

方式一: 通過Object類中的getObject()方法

　　Person p = new Person();

　　Class c = p.getClass();

//方式二: 通過 類名.class 獲取到位元組碼檔案物件（任意資料型別都具備一個class靜態屬性,看上去要比第一種方式簡單）。
Class c2 = Person.class;

//方式三: 通過Class類中的方法（將類名作為字串傳遞給Class類中的靜態方法forName即可）。

　　Class c3 = Class.forName("Person");

注意：第三種和前兩種的區別

前兩種你必須明確Person型別.

後面是指定這種型別的字串就行.這種擴充套件更強.我不需要知道你的類.我只提供字串,按照配置檔案載入就可以了

通過反射獲取構造方法並使用

/*
 * 獲取.class位元組碼檔案物件的方式
 *         1：通過Object類中的getObject()方法
 *         2: 通過 類名.class 獲取到位元組碼檔案物件 
*         3: 反射中的方法,
 *             public static Class<?> forName(String className) throws ClassNotFoundException
 *             返回與帶有給定字串名的類或介面相關聯的 Class 物件 
  
*/
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1： 通過Object類中的getObject()方法
        // Person p1 = new Person();
        // Class c1 = p1.getClass();
        // System.out.println("c1 = "+ c1);

        // 2: 通過 類名.class 獲取到位元組碼檔案物件
        // Class c2 = Person.class;
         
// System.out.println("c2 = "+ c2);

        // 3: 反射中的方法
        Class c3 = Class.forName("cn.oracle_01_Reflect.Person");// 包名.類名
        System.out.println("c3 = " + c3);
    }
}
//    Person類
package cn.oracle_01_Reflect;
public class Person {
    //成員變數
    public String name;
    public int age;
    private String address;

    //構造方法
    public Person() {
        System.out.println("空引數構造方法");
    }
    
    public Person(String name) {
        this.name = name;
        System.out.println("帶有String的構造方法");
    }
    //私有的構造方法
    private Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("帶有String，int的構造方法");
    }
    
    public Person(String name, int age, String address){
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("帶有String, int, String的構造方法");
    }
    
    //成員方法
    //沒有返回值沒有引數的方法
    public void method1(){
        System.out.println("沒有返回值沒有引數的方法");
    }
    //沒有返回值，有引數的方法
    public void method2(String name){
        System.out.println("沒有返回值，有引數的方法 name= "+ name);
    }
    //有返回值，沒有引數
    public int method3(){
        System.out.println("有返回值，沒有引數的方法");
        return 123;
    }
    //有返回值，有引數的方法
    public String method4(String name){
        System.out.println("有返回值，有引數的方法");
        return "哈哈" + name;
    }
    //私有方法
    private void method5(){
        System.out.println("私有方法");
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", address=" + address+ "]";
    }
}

獲取構造方法的程式碼演示：

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
        //獲取Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");//包名.類名
        
        //獲取所有的構造方法
        //Constructor[] cons = c.getConstructors();
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
        
        System.out.println("------------------------");
        //獲取一個構造方法
        //public Person() 
        Constructor con1 = c.getConstructor(null);
        System.out.println(con1);
        
        //public Person(String name)
        Constructor con2 = c.getConstructor(String.class);
        System.out.println(con2);
        
        //private Person(String name, int age)
        Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(con3);
        
        //public Person(String name, int age, String address)
        Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
        System.out.println(con4);
    }
}

通過反射方式，獲取構造方法，建立物件

步驟如下：

1. 獲取到Class物件

2. 獲取指定的構造方法

3. 通過構造方法類Constructor中的方法，建立物件

public T newInstance(Object... initargs)

//    程式碼演示
public class ConstructorDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //1,獲取到Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");//包名.類名
        //2,獲取指定的構造方法
        //public Person()
        //Constructor con = c.getConstructor(null);
        
        //public Person(String name, int age, String address)
        Constructor con = c.getConstructor(String.class, int.class, String.class);
        
        //3,通過構造方法類中Constructor的方法，建立物件
        //Object obj = con.newInstance(null);
        Object obj = con.newInstance("小明", 22, "哈爾濱");
        
        //顯示
        System.out.println(obj);
    }
}

通過反射獲取成員變數並使用

在反射機制中，把類中的成員變數使用類Field表示。可通過Class類中提供的方法獲取成員變數：

返回一個成員變數：

public Field getField(String name) 獲取指定的 public修飾的變數

public Field getDeclaredField(String name) 獲取指定的任意變數

返回多個成員變數

public Field[] getFields() 獲取所有public 修飾的變數

public Field[] getDeclaredFields() 獲取所有的變數 (包含私有)

獲取成員變數的程式碼演示：

public class FieldDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
        //獲取Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");
        
        //獲取成員變數
        //多個變數
        //Field[] fields = c.getFields();
        Field[] fields =  c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-----------------");
        //一個變數
        //public int age;
        Field ageField = c.getField("age");
        System.out.println(ageField);
        
        //private String address
        Field addressField = c.getDeclaredField("address");
        System.out.println(addressField);
    }
}

通過反射，建立物件，獲取指定的成員變數，進行賦值與獲取值操作

獲取成員變數，步驟如下：

1. 獲取Class物件

2. 獲取構造方法

3. 通過構造方法，建立物件

4. 獲取指定的成員變數（私有成員變數，通過setAccessible(booleanflag)方法暴力訪問）

5. 通過方法，給指定物件的指定成員變數賦值或者獲取值

//    程式碼演示：
public class FieldDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
        //1,獲取Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");
        //2，獲取構造方法
        //public Person(String name) 
        Constructor con = c.getConstructor(String.class);
        //3，通過構造方法，建立物件
        Object obj = con.newInstance("小明");
        //4，獲取指定的成員變數
        //public String name;
        Field nameField = c.getField("name");
        //public int age;
        Field ageField = c.getField("age");
        //private String address;
        Field addressField = c.getDeclaredField("address");
        addressField.setAccessible(true); //取消 Java 語言訪問檢查
        
        //5，通過方法，給指定物件的指定成員變數賦值或者獲取值
        System.out.println("name = "+ nameField.get(obj));
        System.out.println("age = "+ ageField.get(obj));
        System.out.println("address = "+ addressField.get(obj));
        
        //賦值
        ageField.set(obj, 23);
        addressField.set(obj, "凱利廣場");
        
        System.out.println("------------------------");
        System.out.println("name = "+ nameField.get(obj));
        System.out.println("age = "+ ageField.get(obj));
        System.out.println("address = "+ addressField.get(obj));
    }
}

通過反射獲取成員方法並使用

在反射機制中，把類中的成員方法使用類Method表示。可通過Class類中提供的方法獲取成員方法：

public class MethodDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
        //獲取Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");
        
        //獲取多個方法
        //Method[] methods = c.getMethods();
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        
        System.out.println("-----------------------");
        //獲取一個方法：
        //public void method1()
        Method method = c.getMethod("method1", null);
        System.out.println(method);
        //public String method4(String name){
        method = c.getMethod("method4", String.class);
        System.out.println(method);
        //私有方法
        //private void method5()
        method = c.getDeclaredMethod("method5", null);
        System.out.println(method);
    }
}

通過反射，建立物件，呼叫指定的方法

獲取成員方法，步驟如下：

1. 獲取Class物件

2. 獲取構造方法

3. 通過構造方法，建立物件

4. 獲取指定的方法

5. 執行找到的方法

public class MethodDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //1， 獲取Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");
        //2,獲取構造方法
        //public Person(String name, int age, String address){
        Constructor con = c.getConstructor(String.class, int.class, String.class);
        //3，通過構造方法，建立物件
        Object obj = con.newInstance("小明", 23, "哈爾濱");
        //4，獲取指定的方法
        //public void method1()  沒有返回值沒有引數的方法
        //Method m1 = c.getMethod("method1", null);
        
        //public String method4(String name)
        Method m4 = c.getMethod("method4", String.class);
        
        //5，執行找到的方法
        //m1.invoke(obj, null);
        
        Object result = m4.invoke(obj, "oracle");
        System.out.println("result = " + result);
    }
}

通過反射，建立物件，呼叫指定的private 方法

取私有成員方法，步驟如下：

1. 獲取Class物件

2. 獲取構造方法

3. 通過構造方法，建立物件

4. 獲取指定的方法

5. 開啟暴力訪問

6. 執行找到的方法

public class MethodDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //1， 獲取Class物件
        Class c = Class.forName("cn.oracle_01_Reflect.Person");
        //2,獲取構造方法
        //public Person(String name, int age, String address){
        Constructor con = c.getConstructor(String.class, int.class, String.class);
        //3，通過構造方法，建立物件
        Object obj = con.newInstance("小明", 23, "哈爾濱");
        //4，獲取指定的方法
        //private void method5(){
        Method m5 = c.getDeclaredMethod("method5", null);
        //5,開啟暴力訪問
        m5.setAccessible(true);
        //6，執行找到的方法
        m5.invoke(obj, null);
    }
}

反射練習

其實程式編譯後產生的.class檔案中是沒有泛型約束的，這種現象我們稱為泛型的擦除。那麼，我們可以通過反射技術，來完成向有泛型約束的集合中，新增任意型別的元素

public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //新增元素到集合
        list.add(new Integer(30));
        list.add(new Integer("12345"));
        list.add(123);
        //list.add("哈哈");//因為有泛型型別的約束
        System.out.println(list);
        
        //通過反射技術，實現新增任意型別的元素
        //1, 獲取位元組碼檔案物件
        //Class c = list.getClass();
        //Class c = ArrayList.class;
        Class c = Class.forName("java.util.ArrayList");
        
        //2, 找到add()方法
        // public boolean add(E e)
        Method addMethod = c.getMethod("add", Object.class);
        
        //3，  執行add()方法
        addMethod.invoke(list, "哈哈");// list.add("哈哈");
        System.out.println(list);
    }
}

反射配置檔案

通過反射配置檔案，執行配置檔案中指定類的對應方法

className=cn.oracle_01_Reflect.Person
methodName=method5

讀取配置檔案，呼叫指定類中的對應方法

public class ReflectTest2 {
    public static void main(String[] args)
            throws FileNotFoundException, IOException, ClassNotFoundException, NoSuchMethodException, SecurityException,
            InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // 通過Properties集合從檔案中讀取資料
        Properties prop = new Properties();
        // 讀取檔案中的資料到集合中
        prop.load(new FileInputStream("properties.txt"));
        // 獲取鍵所對應的值
        String className = prop.getProperty("className");
        System.out.println(className);

        // 1，獲取Person.class 位元組碼檔案物件
        Class c = Class.forName(className);
        // 2，獲取構造方法
        // public Person(String name, int age, String address)
        Constructor con = c.getConstructor(String.class, int.class, String.class);

        // 3,建立物件
        Object obj = con.newInstance("小明", 20, "中國");
        System.out.println(obj);

        // 4，獲取指定的方法
        // private void method5(){}
        String methodName = prop.getProperty("methodName");
        Method m5 = c.getDeclaredMethod(methodName, null);
        // 5,開啟暴力訪問
        m5.setAccessible(true);
        // 6，執行找到的方法
        m5.invoke(obj, null);
    }
}

java---類載入器和反射

類的載入當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連線，初始化三步來實現對這個類進行初始化。

Java基礎18--類載入器和反射機制

1 類載入器 1.1 類載入類載入的描述當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過類的載入，類的連線，類的初始化這三個步驟來對類進行初始化。如果不出現意外情況，JVM將會連續完成這三個

011類載入器和反射

類載入器和反射類載入器概述類初始化時機類載入器反射反射概述class拿到class位元組碼檔案物件獲取父類class構造方法Constructor。獲取構造方法呼叫構造方法強制轉換（一般不用）強制訪問Field成員變數獲取所有publi

類載入器和反射

一、類載入器　　1、類的載入　　　　當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連線，初始化三步來實現對這個類進行初始化。

java類載入機制和類載入器以及雙親委派原則解析

關於類載入器和類載入機制，這個也算是老生常談了，可能大家或多或少都有一些瞭解，但是如果真的要讓你說出個123來，可能還是有點困難，所以今天也是花了一天時間，從頭複習了一遍。

jvm之java類載入機制和類載入器(ClassLoader)的用法

當程式主動使用某個類時，如果該類還未被載入到記憶體中，則JVM會通過載入、連線、初始化3個步驟來對該類進行初始化。如果沒有意外，JVM將會連續完成3個步驟，所以有時也把這個3個步驟統稱為類載入或類初始化。

反射機制：ClassLoader類載入器和 reflect中的array使用

技術標籤：2020Java程式 ClassLoader 載入、連線、初始化原理載入以JVM程序為基本單位 1）每個程式（public class方法都會開闢一個新的JVM程序；故不同程式的記憶體不會共享（哪怕是靜態方法））； 2）載入二

Java類載入器與Java反射

一、Java類載入器當程式要使用某個類時，如果該類還沒有被載入到記憶體中，JVM會通過載入、連線、初始化三個步驟，實現對這個類的初始化。

Java類載入器ClassLoader用法解析

這篇文章主要介紹了Java類載入器ClassLoader用法解析,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java類載入連線和初始化原理解析

1、當程式使用某個類時，JVM將會完成以下這三個步驟 2、連線　　1）驗證　　　　驗證是否是合法的位元組碼檔案。驗證JDK版本是否正確等。

淺談JAVA 類載入器

類載入機制類載入器負責載入所有的類，系統為所有被載入記憶體中的類生成一個 java.lang.Class 例項。一旦一個類被載入 JVM 中，同個類就不會被再次載入了。現在的問題是，怎麼樣才算“同一個類”？

Java類載入器層次結構原理解析

類載入器的層次結構：引導類載入器（bootstrap class loader）　　用來載入java的核心庫（JAVA_HOME/jre/lib/rt.jar,或sun.boot.class.path路徑下的內容），是用原生程式碼來實現的（C實現的），並不繼承自java.la

結合JVM 淺談Java 類載入器（Day_03）

　　　所謂錯過，不是錯了，而是過了。什麼是JAVA類載入？ Class物件由JVM自動產生，每當一個類被載入時，JVM就自動為其生成一個Class物件，通過Class物件可以獲得類的相關資訊。將類資訊讀取到記憶體中的過程，

java類載入器的父親委託機制詳細介紹

>>> 講解一下ClassLoader這個類 java.lang.Object java.lang.ClassLoader 類載入器是負責載入類的物件。ClassLoader類是一個抽象類。如果給定類的二進位制名稱，那麼類載入器會試圖查詢或生成

類載入器&反射

1.類載入器 1.1類的載入概述：當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過載入，連線，初始化三步來實現對這個類的初始化。如果不出現意外情況，JVM將會連續完成這三個步驟，所以有時也把這

原始碼解析Java類載入器

參考內容：深入理解Java虛擬機器(JVM高階特性與最佳實踐) ——周志明老師尚矽谷深入理解JVM教學視訊——宋紅康老師

JavaSE24-類載入器&反射&模組化

1.類載入器 1.1 類載入類載入的描述　　當程式要使用某個類時，如果該類還未被載入到記憶體中，則系統會通過類的載入，類的連線，類的初始化這三個步驟來對類進行初始化。如果不出現意外情況，JVM將會連續完成這三

圖解類載入器和雙親委派機制，一看就懂

聽說微信搜尋《Java魚仔》會變更強哦！本文收錄於JavaStarter，裡面有我完整的Java系列文章，學習或面試都可以看看哦

自定義JAVA類載入器

技術標籤：java/J2SE 轉自:http://blog.csdn.net/seu_calvin/article/details/52315125 (問：自定義類載入器怎麼實現，其中哪個方法走雙親委派模型，（實現findclass方法，一般用defineclass載入外部類），如何才

Java 類載入器

類與類載入器對於任意一個類，必須由載入它的類載入器和這個類本身一起共同確立其在Java虛擬機器中的唯一性，每一個類載入器，都擁有一個獨立的類名稱空間。

java---類載入器和反射

類的載入

通過反射獲取構造方法並使用

通過反射方式，獲取構造方法，建立物件

通過反射獲取成員變數並使用

通過反射，建立物件，獲取指定的成員變數，進行賦值與獲取值操作

通過反射獲取成員方法並使用

通過反射，建立物件，呼叫指定的方法

通過反射，建立物件，呼叫指定的private 方法

反射練習

反射配置檔案

相關推薦