內容介紹

類加載器
反射構造方法
反射成員變量
反射成員方法
反射配置文件運行類中的方法

1 類加載器

1.1 類的加載

當程序要使用某個類時，如果該類還未被加載到內存中，則系統會通過加載，連接，初始化三步來實現對這個類進行初始化。

加載

就是指將class文件讀入內存，併爲之創建一個Class對象。

任何類被使用時系統都會建立一個Class對象

連接

　　驗證是否有正確的內部結構，並和其他類協調一致

　　準備負責爲類的靜態成員分配內存，並設置默認初始化值

　　解析將類的二進制數據中的符號引用替換爲直接引用

初始化

　　就是我們以前講過的初始化步驟

1.2 類初始化時機

1. 創建類的實例

2. 類的靜態變量，或者爲靜態變量賦值

3. 類的靜態方法

4. 使用反射方式來強制創建某個類或接口對應的java.lang.Class對象

5. 初始化某個類的子類

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

1.3 類加載器

負責將.class文件加載到內在中，併爲之生成對應的Class對象。
雖然我們不需要關心類加載機制，但是瞭解這個機制我們就能更好的理解程序的運行

1.4 類加載器的組成

Bootstrap ClassLoader 根類加載器

　　也被稱爲引導類加載器，負責Java核心類的加載

　　比如System,String等。在JDK中JRE的lib目錄下rt.jar文件中

Extension ClassLoader 擴展類加載器

　　負責JRE的擴展目錄中jar包的加載。

System ClassLoader 系統類加載器

　　負責在JVM啓動時加載來自java命令的class文件，以及classpath環境變量所指定的jar包和類路徑。

通過這些描述就可以知道我們常用的類，都是由誰來加載完成的。到目前爲止我們已經知道把class文件加載到內存了，那麼，如果我們僅僅站在這些class文件的角度，我們如何來使用這些class文件中的內容呢?這就是我們反射要研究的內容。

2 反射

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

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

2.1 Class類

閱讀API的Class類得知，Class 沒有公共構造方法。Class 對象是在加載類時由 Java 虛擬機以及通過調用類加載器中的 defineClass 方法自動構造的

獲取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("com.test_Reflect.Person");// 包名.類名
        System.out.println("c3 = " + c3);
    }
}

Person類

package com.test_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+ "]";
    }
}

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

在反射機制中，把類中的成員（構造方法、成員方法、成員變量）都封裝成了對應的類進行表示。其中，構造方法使用類Constructor表示。可通過Class類中提供的方法獲取構造方法：

返回一個構造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes) 獲取public修飾, 指定參數類型所對應的構造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 獲取指定參數類型所對應的構造方法(包含私有的)

返回多個構造方法

public Constructor<?>[] getConstructors() 獲取所有的public 修飾的構造方法

public Constructor<?>[] getDeclaredConstructors() 獲取所有的構造方法(包含私有的)

獲取構造方法的代碼演示：

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
        //獲取Class對象
        Class c = Class.forName("cn.itcast_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);
    }
}

2.2.1 通過反射方式，獲取構造方法，創建對象

獲取構造方法，步驟如下：

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.itcast_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);
    }
}

2.2.2 通過反射方式，獲取私有構造方法，創建對象

AccessibleObject 類是 Field、Method 和 Constructor 對象的父類。它提供了將反射的對象標記爲在使用時取消默認 Java 語言訪問控制檢查的能力。

對於公共成員、默認（打包）訪問成員、受保護成員和私有成員，在分別使用 Field、Method 或 Constructor 對象來設置或獲取字段、調用方法，或者創建和初始化類的新實例的時候，會執行訪問檢查。常用方法如下：

public void setAccessible(boolean flag) throws SecurityException

參數值爲 true 則指示反射的對象在使用時應該取消 Java 語言訪問檢查。參數值爲 false 則指示反射的對象應該實施 Java 語言訪問檢查。

獲取私有構造方法，步驟如下：

1. 獲取到Class對象

2. 獲取指定的構造方法

3. 暴力訪問, 通過setAccessible(boolean flag)方法

4. 通過構造方法類Constructor中的方法，創建對象

public T newInstance(Object... initargs)

代碼演示：

public class ConstructorDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //1,獲取到Class對象
        Class c = Class.forName("cn.itcast_01_Reflect.Person");//包名.類名
        
        //2,獲取指定的構造方法
        //private Person(String name, int age)
        Constructor con = c.getDeclaredConstructor(String.class, int.class);
        
        //3,暴力反射 
        con.setAccessible(true);//取消 Java 語言訪問檢查
        
        //4,通過構造方法類中的功能，創建對象
        Object obj = con.newInstance("小明", 23);
        System.out.println(obj);
        
    }
}

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

在反射機制中，把類中的成員變量使用類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.itcast_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);
    }
}

2.3.1 通過反射，創建對象，獲取指定的成員變量，進行賦值與獲取值操作

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

1. 獲取Class對象

　　2. 獲取構造方法

　　3. 通過構造方法，創建對象

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

　　5. 通過方法，給指定對象的指定成員變量賦值或者獲取值

　　　　 public void set(Object obj, Object value) 在指定對象obj中，將此 Field 對象表示的成員變量設置爲指定的新值

　　　　 public Object get(Object obj) 返回指定對象obj中，此 Field 對象表示的成員變量的值

代碼演示：

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.itcast_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));
    }
}

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

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

返回獲取一個方法：

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

獲取public 修飾的方法

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

獲取任意的方法，包含私有的

　　　　參數1: name 要查找的方法名稱；參數2： parameterTypes 該方法的參數類型

返回獲取多個方法：

　　　　 public Method[] getMethods() 獲取本類與父類中所有public 修飾的方法

　　　　public Method[] getDeclaredMethods() 獲取本類中所有的方法(包含私有的)

獲取成員方法的代碼演示：

public class MethodDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
        //獲取Class對象
        Class c = Class.forName("cn.itcast_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);
    }
}

2.4.1 通過反射，創建對象，調用指定的方法

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

　　1. 獲取Class對象

　　2. 獲取構造方法

　　3. 通過構造方法，創建對象

4. 獲取指定的方法

5. 執行找到的方法

　　　　 public Object invoke(Object obj, Object... args) 執行指定對象obj中，當前Method對象所代表的方法，方法要傳入的參數通過args指定。

代碼演示：

public class MethodDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //1， 獲取Class對象
        Class c = Class.forName("com.test_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, "itcast");
        System.out.println("result = " + result);
    }
}

2.4.2 通過反射，創建對象，調用指定的private 方法

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

　　1. 獲取Class對象

　　2. 獲取構造方法

　　3. 通過構造方法，創建對象

　　4. 獲取指定的方法

　　5. 開啓暴力訪問

　　6. 執行找到的方法

　　　　 public Object invoke(Object obj, Object... args) 執行指定對象obj中，當前Method對象所代表的方法，方法要傳入的參數通過args指定。

代碼演示：

public class MethodDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        //1， 獲取Class對象
        Class c = Class.forName("cn.itcast_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);
    }
}

3 反射練習

3.1 泛型擦除

思考，將已存在的ArrayList<Integer>集合中添加一個字符串數據，如何實現呢？

我來告訴大家，其實程序編譯後產生的.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);
    }
}

3.2 反射配置文件

通過反射配置文件，運行配置文件中指定類的對應方法

讀取Peoperties.txt文件中的數據，通過反射技術，來完成Person對象的創建

Peoperties.txt文件內容如下：

className=com.test_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之反射

1 類加載器

1.1 類的加載

1.2 類初始化時機

1.3 類加載器

1.4 類加載器的組成

2 反射

2.1 Class類

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

2.2.1 通過反射方式，獲取構造方法，創建對象

2.2.2 通過反射方式，獲取私有構造方法，創建對象

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

2.3.1 通過反射，創建對象，獲取指定的成員變量，進行賦值與獲取值操作

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

2.4.1 通過反射，創建對象，調用指定的方法

2.4.2 通過反射，創建對象，調用指定的private 方法

3 反射練習

3.1 泛型擦除

3.2 反射配置文件

Vue 響應式原理模擬以及最小版本的 Vue的模擬

gulp涉及的自動化構建的插件gulp-load-plugins,gulp-sass,gulp-imagemin等以及啓動服務browser-sync相關操作

模擬Promise的功能

JS的函數式編程範式

學習apply()方法的使用,記錄一下

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結