類加載器

類的加載

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

加載就是指將class文件讀入內存，並為之創建一個Class對象。任何類被使用時系統都會建立一個Class對象。

鏈接指的是將Java類的二進制代碼合並到JVM的運行狀態之中的過程。在鏈接之前，這個類必須被成功加載。類的鏈接包括驗證、準備和解析等幾個步驟。

• 驗證：是否有正確的內部結構，並和其他類協調一致。
• 準備：負責為類的靜態成員分配內存，並設置默認初始化值
• 解析：將類的二進制數據中的符號引用替換為直接引用

初始化就是以前講過的初始化步驟，類初始化時機：

• 創建類的實例
• 訪問類的靜態變量，或者為靜態變量賦值
• 訪問類的靜態方法
• 使用反射方式來強制創建某個類或接口對應的java.lang.Class對象
• 初始化某個類的子類
• 直接使用java.exe命令來運行某個主類

類加載器

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

類加載器的組成

Bootstrap ClassLoader 根類加載器，也被稱為引導類加載器，負責Java核心類的加載。比如System,String等。在JDK中JRE的lib目錄下rt.jar文件中。

Extension ClassLoader 擴展類加載器，負責JRE的擴展目錄中jar包的加載，在JDK中JRE的lib目錄下ext目錄。

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

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

反射

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

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

Class類

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

獲取Class對象的三種方式

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

Person p = new Person();
Class c = p.getClass();

方式二: 通過 類名.class 獲取到字節碼文件對象（任意數據類型都具備一個class靜態屬性,看上去要比第一種方式簡單）。

Class c2 = Person.class;

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

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

前兩種你必須明確Person類型。第三種是指定這種類型的字符串就行.這種擴展更強.我不需要知道你的類.我只提供字符串,按照配置文件加載就可以了。

代碼演示：

package typeinfo;

/* 獲取.class字節碼文件對象的方式
* 1：通過Object類中的getClass()方法
* 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類中的getClass()方法
        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("typeinfo.Person");// 包名.類名
        System.out.println("c3 = " + c3);
    }
}
//c1 = class typeinfo.Person
//c2 = class typeinfo.Person
//c3 = class typeinfo.Person

package typeinfo;
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+ "]";
    }
}

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

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

返回一個構造方法：

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

返回多個構造方法

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

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

package typeinfo;

import java.lang.reflect.Constructor;

public class ReflectConstructorDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
//獲取Class對象
        Class c = Class.forName("typeinfo.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);
    }
}
//public typeinfo.Person(java.lang.String,int,java.lang.String)
//private typeinfo.Person(java.lang.String,int)
//public typeinfo.Person(java.lang.String)
//public typeinfo.Person()
//        ------------------------
//public typeinfo.Person()
//public typeinfo.Person(java.lang.String)
//private typeinfo.Person(java.lang.String,int)
//public typeinfo.Person(java.lang.String,int,java.lang.String)

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

步驟如下：

1. 獲取到Class對象

2. 獲取指定的構造方法

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

代碼演示：

package typeinfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ConstructorDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, 
                       InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {
//1,獲取到Class對象
        Class c = Class.forName("typeinfo.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);
    }
}
//帶有String, int, String的構造方法
//Person [name=小明, age=22, address=哈爾濱]

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

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中的 newInstance 方法，創建對象

代碼演示：

package typeinfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ConstructorDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, 
                                           InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//1,獲取到Class對象
        Class c = Class.forName("typeinfo.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);
    }
}
//帶有String，int的構造方法
//Person [name=小明, age=23, address=null]

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

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

返回一個成員變量

public Field getField(String name) 獲取指定的public修飾的變量
public Field getDeclaredField(String name) 獲取指定的任意變量(包含私有)

返回多個成員變量

public Field[] getFields() 獲取所有public修飾的變量
public Field[] getDeclaredFields() 獲取所有的變量 (包含私有)

獲取成員變量的代碼演示：

package typeinfo;

import java.lang.reflect.Field;

public class FieldDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
//獲取Class對象
        Class c = Class.forName("typeinfo.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);
    }
}
//public java.lang.String typeinfo.Person.name
//public int typeinfo.Person.age
//private java.lang.String typeinfo.Person.address
//        -----------------
//public int typeinfo.Person.age
//private java.lang.String typeinfo.Person.address
//
//        Process finished with exit code 0

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

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

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 對象表示的成員變量的值。

代碼演示：

package typeInfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * Created by yang on 2017/7/4.
 */
public class FieldDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
//1,獲取Class對象
        Class c = Class.forName("typeInfo.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));
    }
}
//帶有String的構造方法
//name = 小明
//age = 0
//address = null
//------------------------
//name = 小明
//age = 23
//address = 凱利廣場

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

在反射機制中，把類中的成員方法使用類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() //獲取本類中所有的方法(包含私有的)

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

package typeInfo;

import java.lang.reflect.Method;

/**
 * Created by yang on 2017/7/4.
 */
public class MethodDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
//獲取Class對象
        Class c = Class.forName("typeInfo.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);
    }
}
//public java.lang.String typeInfo.Person.toString()
//public void typeInfo.Person.method2(java.lang.String)
//public int typeInfo.Person.method3()
//public java.lang.String typeInfo.Person.method4(java.lang.String)
//public void typeInfo.Person.method1()
//private void typeInfo.Person.method5()
//        -----------------------
//public void typeInfo.Person.method1()
//public java.lang.String typeInfo.Person.method4(java.lang.String)
//private void typeInfo.Person.method5()

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

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

1. 獲取Class對象

2. 獲取構造方法

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

4. 獲取指定的方法

5. 執行找到的方法

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

代碼演示：

package typeInfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Created by yang on 2017/7/4.
 */
public class MethodDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
            InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {

//1， 獲取Class對象
        Class c = Class.forName("typeInfo.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, "yyb");
        System.out.println("result = " + result);
    }
}

//帶有String, int, String的構造方法
//有返回值，有參數的方法
//result = 哈哈yyb

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

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

1. 獲取Class對象

2. 獲取構造方法

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

4. 獲取指定的方法

5. 開啟暴力訪問

6. 執行找到的方法

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

代碼演示：

package typeInfo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Created by yang on 2017/7/4.
 */
public class MethodDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException,
                           IllegalAccessException, IllegalArgumentException, InvocationTargetException, InvocationTargetException {
//1， 獲取Class對象
        Class c = Class.forName("typeInfo.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);
    }
}
//帶有String, int, String的構造方法
//私有方法

泛型擦除

將已存在的ArrayList<Integer>集合中添加一個字符串數據，如何實現呢？其實程序編譯後產生的.class文件中是沒有泛型約束的，這種現象我們稱為泛型的擦除。那麽，我們可以通過反射技術，來完成向有泛型約束的集合中，添加任意類型的元素。

代碼如下：

package typeInfo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * Created by yang on 2017/7/4.
 */
public class ReflectTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
            IllegalAccessException, IllegalArgumentException, InvocationTargetException, 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);
    }
}
//[30, 12345, 123]
//[30, 12345, 123, 哈哈]

反射配置文件

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

讀取Peoperties.txt文件中的數據，通過反射技術，來完成Person對象的創建，Peoperties.txt（放在src目錄下）文件內容如下：

className=typeInfo.Person
methodName=method5

讀取配置文件，調用指定類中的對應方法

package typeInfo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * Created by yang on 2017/7/4.
 */
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("src/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);
    }
}

//typeInfo.Person
//帶有String, int, String的構造方法
//Person [name=小明, age=20, address=中國]
//私有方法

Java基礎學習筆記二十三 Java核心語法之反射