1. 程式人生 > >Java基礎學習筆記二十三 Java核心語法之反射

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

負責 目錄 boolean tostring 筆記 str 編譯 三種 進制

類加載器

類的加載

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

加載就是指將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核心語法之反射