【04】Java語言進階特性注解與反射

（1）一個人隻要自己不放棄自己，整個世界也不會放棄你.

（2）天生我才必有大用

（3）不能忍受學習之苦就一定要忍受生活之苦，這是多麼痛苦而深刻的領悟.

（4）做難事必有所得

（5）精神乃真正的刀鋒

（6）戰勝對手有兩次，第一次在内心中.

（7）好好活就是做有意義的事情.

（8）亡羊補牢，為時未晚

（9）科技領域，沒有捷徑與投機取巧。

（10）有實力，一年365天都是應聘的旺季，沒實力，天天都是應聘的淡季。

（11）基礎不牢，地動天搖

（12）寫部落格初心：成長自己，輔助他人。當某一天離開人世，希望部落格中的思想還能幫人指引方向.

（13）編寫實屬不易，若喜歡或者對你有幫助記得點贊+關注或者收藏哦~

Java語言進階特性注解與反射

文章目錄

• Java語言進階特性注解與反射
• • 1.Java語言的重要性
  • 2.注解
  • • 2.1注解聲明
    • • 2.1.1聲明一個注解類型
      • 2.1.2元注解
      • • [email protected]
        • 2.1.2.2 @Retention
      • 2.1.3注解類型元素
  • 3.注解應用場景
  • • 3.1SOURCE
    • • 3.1.1IDE文法檢查
      • 3.1.2APT注解處理器
    • 3.2CLASS
    • 3.3RUNTIME
  • 4.反射
  • • 4.1Class
    • 4.2獲得 Class 對象
    • 4.3判斷是否為某個類的執行個體
    • 4.4建立執行個體
    • 4.5擷取構造器資訊
    • 4.6擷取類的成員變量（字段）資訊
    • 4.7調用方法
    • 4.8利用反射建立數組
    • 4.9反射擷取泛型真實類型
    • • 4.9.1TypeVariable
      • 4.9.2ParameterizedType
      • 4.9.3GenericArrayType
      • 4.9.4WildcardType
      • 4.9.5Gson反序列化
  • 5.打賞鼓勵
  • • 5.1微信打賞
    • 5.2支付寶打賞

1.Java語言的重要性

Java知識是作為Android開發的語言基礎，雖然現在已經推出了kotlin，但是基于以下原因我們還是需要好好牢牢掌握java。

（1）SDK還是java，kotlin也需要編譯成為java運作；

（2）Java語言應用不僅僅在Android，就是在背景開發中也是一個最流行的語言；

（3）大公司面試都要求我們有紮實的Java語言基礎。

2.注解

（1）Java 注解（Annotation）又稱 Java 标注，是 JDK5.0 引入的一種注釋機制。

（2）注解是中繼資料的一種形式，提供有關于程式但不屬于程式本身的資料。

（3）注解對它們注解的代碼的操作沒有直接影響。

2.1注解聲明

2.1.1聲明一個注解類型

（1）Java中所有的注解，預設實作Annotation 接口

public interface Annotation {
    boolean equals(Object var1);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}
           

（2）與聲明一個"Class"不同的是，注解的聲明使用@interface 關鍵字。一個注解的聲明如下

public @interface Lance{

}
           

2.1.2元注解

（1）在定義注解時，注解類也能夠使用其他的注解聲明。

（2）對注解類型進行注解的注解類，我們稱之為 metaannotation（元注解）。

（3）一般的，我們在定義自定義注解時，需要指定的元注解有兩個 ：

• @Documented 元注解：用于被javadoc工具提取成文檔。
• @Inherited 元注解：表示允許子類繼承父類中定義的注解。

[email protected]

（1）注解标記另一個注解，以限制可以應用注解的 Java 元素類型。

（2）目标注解指定以下元素類型之一作為其值：

• ElementType.ANNOTATION_TYPE 可以應用于注解類型。
• ElementType.CONSTRUCTOR 可以應用于構造函數。
• ElementType.FIELD 可以應用于字段或屬性。
• ElementType.LOCAL_VARIABLE 可以應用于局部變量。
• ElementType.METHOD 可以應用于方法級注解。
• ElementType.PACKAGE 可以應用于包聲明。
• ElementType.PARAMETER 可以應用于方法的參數。
• ElementType.TYPE 可以應用于類的任何元素。

2.1.2.2 @Retention

（1）注解指定标記注解的存儲方式：

• RetentionPolicy.SOURCE - 标記的注解僅保留在源級别中，并被編譯器忽略。
• RetentionPolicy.CLASS - 标記的注解在編譯時由編譯器保留，但 Java 虛拟機(JVM)會忽略。
• RetentionPolicy.RUNTIME - 标記的注解由 JVM 保留，是以運作時環境可以使用它。

（2）@Retention 三個值中 SOURCE < CLASS < RUNTIME，即CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。下文會介紹他們不同的應用場景。

（3）下面來看例子：

//@Target(ElementType.TYPE) 隻能在類上标記該注解
@Target({ElementType.TYPE,ElementType.FIELD}) // 允許在類與類屬性上标記該注解
@Retention(RetentionPolicy.SOURCE) //注解保留在源碼中
public @interface Lance {
}
           

2.1.3注解類型元素

（1）在上文元注解中，允許在使用注解時傳遞參數。

（2）我們也能讓自定義注解的主體包含 annotation type element (注解類型元素) 聲明，它們看起來很像方法，可以定義可選的預設值。

@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.SOURCE)
public @interface Lance {
String value(); //無預設值
int age() default 1; //有預設值
}
           

（3）注意：在使用注解時，如果定義的注解中的類型元素無預設值，則必須進行傳值。

//如果隻存在value元素需要傳值的情況，則可以省略:元素名=
@Lance("帥") 
@Lance(value="帥",age = 2)
int i;
           

3.注解應用場景

按照@Retention 元注解定義的注解存儲方式，注解可以被在三種場景下使用：

3.1SOURCE

（1）RetentionPolicy.SOURCE ，作用于源碼級别的注解，可提供給IDE文法檢查、APT等場景使用。

（2）在類中使用SOURCE 級别的注解，其編譯之後的class中會被丢棄。

3.1.1IDE文法檢查

（1）在Android開發中， support-annotations 與androidx.annotation) 中均有提供@IntDef 注解，此注解的定義如下：

@Retention(SOURCE) //源碼級别注解
@Target({ANNOTATION_TYPE})
public @interface IntDef {
    int[] value() default {};
    boolean flag() default false;
    boolean open() default false;
}
           

（1）Java中Enum(枚舉)的實質是特殊單例的靜态成員變量，在運作期所有枚舉類作為單例，全部加載到記憶體中。比常量多5到10倍的記憶體占用。

（2）此注解的意義在于能夠取代枚舉，實作如方法入參限制。

（3）如：我們定義方法test ，此方法接收參數teacher 需要在：Lance、Alvin中選擇一個。如果使用枚舉能夠實作為:

public enum Teacher{
	LANCE,ALVIN
}

public void test(Teacher teacher) {

}

           

（2）而現在為了進行記憶體優化，我們現在不再使用枚舉，則方法定義為：

public static final int LANCE = 1;
public static final int ALVIN = 2;

public void test(int teacher) {

}
           

（3）然而此時，調用test 方法由于采用基本資料類型int，将無法進行類型限定。此時使用@IntDef增加自定義注解：

public static final int LANCE = 1;
public static final int ALVIN = 2;

@IntDef(value = {MAN, WOMEN}) //限定為LANCE，ALVIN
@Target(ElementType.PARAMETER) //作用于參數的注解
@Retention(RetentionPolicy.SOURCE) //源碼級别注解
public @interface Teacher {

}
public void test(@Teacher int teacher) {

}
           

（4）此時，我們再去調用test 方法，如果傳遞的參數不是LANCE 或者ALVIN 則會顯示 Inspection 警告(編譯不會報錯)。

（5）可以修改此類文法檢查級别：

（6）以上注解均為SOURCE 級别，本身IDEA/AS 就是由Java開發的，工具實作了對Java文法的檢查，借助注解能對被注解的特定文法進行額外檢查。

3.1.2APT注解處理器

（1）APT全稱為：“Anotation Processor Tools”，意為注解處理器。顧名思義，其用于處理注解。

（2）編寫好的Java源檔案，需要經過javac 的編譯，翻譯為虛拟機能夠加載解析的位元組碼Class檔案。

（3）注解處理器是 javac 自帶的一個工具，用來在編譯時期掃描處理注解資訊。

（4）你可以為某些注解注冊自己的注解處理器。 注冊的注解處理器由javac調起，并将注解資訊傳遞給注解處理器進行處理。

• 注解處理器是對注解應用最為廣泛的場景。在Glide、EventBus3、Butterknifer、Tinker、ARouter等等常用。
• 架構中都有注解處理器的身影。但是你可能會發現，這些架構中對注解的定義并不是SOURCE 級别，更多的是CLASS 級别，别忘了：CLASS包含了SOURCE，RUNTIME包含SOURCE、CLASS。

3.2CLASS

（1）定義為CLASS 的注解，會保留在class檔案中，但是會被虛拟機忽略(即無法在運作期反射擷取注解)。此時完全符合此種注解的應用場景為位元組碼操作。如：AspectJ、熱修複Roubust中應用此場景。

（2）所謂位元組碼操作即為，直接修改位元組碼Class檔案以達到修改代碼執行邏輯的目的。

（3）在程式中有多處需要進行是否登入的判斷。

（1）如果我們使用普通的程式設計方式，需要在代碼中進行if-else 的判斷，也許存在十個判斷點，則需要在每個判斷點加入此項判斷。

（2）此時，我們可以借助AOP(面向切面)程式設計思想，将程式中所有功能點劃分為： 需要登入與無需登入兩種類型，即兩個切面。對于切面的區分即可采用注解。

//Java源代碼
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface Login {

}

@Login
public void jumpA(){
	startActivity(new Intent(this,AActivity.class));
}

public void jumpB(){
	startActivity(new Intent(this,BActivity.class));
}
           

（1）在上訴代碼中， jumpA 方法需要具備登入身份。而Login 注解的定義被設定為CLASS 。是以我們能夠在該類所編譯的位元組碼中獲得到方法注解Login 。

（2）在操作位元組碼時，就能夠根據方法是否具備該注解來修改class中該方法的内容加入if-else 的代碼段：

//Class位元組碼
@Login
public void jumpA() {
    if (this.isLogin) {
    	this.startActivity(new Intent(this, LoginActivity.class));
    } else {
    	this.startActivity(new Intent(this, AActivity.class));
    }
}

public void jumpB() {
	startActivity(new Intent(this,BActivity.class));
}
           

（3）注解能夠設定類型元素(參數)，結合參數能實作更為豐富的場景，如：運作期權限判定等。

3.3RUNTIME

（1）注解保留至運作期，意味着我們能夠在運作期間結合反射技術擷取注解中的所有資訊。

4.反射

（1）一般情況下，我們使用某個類時必定知道它是什麼類，是用來做什麼的，并且能夠獲得此類的引用。于是我們直接對這個類進行執行個體化，之後使用這個類對象進行操作。

（2）反射則是一開始并不知道我要初始化的類對象是什麼，自然也無法使用 new 關鍵字來建立對象了。這時候，我們使用 JDK 提供的反射 API 進行反射調用。

（3）反射就是在運作狀态中,對于任意一個類,都能夠知道這個類的所有屬性和方法;對于任意一個對象,都能夠調用它的任意方法和屬性;并且能改變它的屬性。是Java被視為動态語言的關鍵。

（4）Java反射機制主要提供了以下功能：

• 在運作時構造任意一個類的對象
• 在運作時擷取或者修改任意一個類所具有的成員變量和方法
• 在運作時調用任意一個對象的方法（屬性）

4.1Class

（1）反射始于Class，Class是一個類，封裝了目前對象所對應的類的資訊。

（2）一個類中有屬性，方法，構造器等，比如說有一個Person類，一個Order類，一個Book類，這些都是不同的類，現在需要一個類，用來描述類，這就是Class，它應該有類名，屬性，方法，構造器等。

（3）Class是用來描述類的類。

（4）Class類是一個對象照鏡子的結果，對象可以看到自己有哪些屬性，方法，構造器，實作了哪些接口等等。

（5）對于每個類而言，JRE 都為其保留一個不變的 Class 類型的對象。一個 Class 對象包含了特定某個類的有關資訊。

（6）對象隻能由系統建立對象，一個類（而不是一個對象）在 JVM 中隻會有一個Class執行個體。

4.2獲得 Class 對象

（1）通過類名擷取 類名.class

（2）通過對象擷取 對象名.getClass()

（3）通過全類名擷取 Class.forName(全類名) classLoader.loadClass(全類名)

• 使用 Class 類的 forName 靜态方法

• 直接擷取某一個對象的 class

Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;
           

• 調用某個對象的 getClass() 方法

StringBuilder str = new StringBuilder("123");
Class<?> klass = str.getClass();
           

4.3判斷是否為某個類的執行個體

（1）一般地，我們用 instanceof 關鍵字來判斷是否為某個類的執行個體。同時我們也可以借助反射中 Class 對象的isInstance() 方法來判斷是否為某個類的執行個體，它是一個 native 方法：

（2）判斷是否為某個類的類型

4.4建立執行個體

（1）通過反射來生成對象主要有兩種方式。

• 使用Class對象的newInstance()方法來建立Class對象對應類的執行個體。

Class<?> c = String.class;
Object str = c.newInstance();
           

• 先通過Class對象擷取指定的Constructor對象，再調用Constructor對象的newInstance()方法來建立執行個體。這種方法可以用指定的構造器構造類的執行個體。

//擷取String所對應的Class對象
Class<?> c = String.class;
//擷取String類帶一個String參數的構造器
Constructor constructor = c.getConstructor(String.class);
//根據構造器建立執行個體
Object obj = constructor.newInstance("23333");
System.out.println(obj);
           

4.5擷取構造器資訊

得到構造器的方法

Constructor getConstructor(Class[] params) -- 獲得使用特殊的參數類型的public構造函數(包括父類）
Constructor[] getConstructors() -- 獲得類的所有公共構造函數
Constructor getDeclaredConstructor(Class[] params) -- 獲得使用特定參數類型的構造函數(包括私有)
Constructor[] getDeclaredConstructors() -- 獲得類的所有構造函數(與接入級别無關)
           

4.6擷取類的成員變量（字段）資訊

獲得字段資訊的方法

Field getField(String name) -- 獲得命名的公共字段
Field[] getFields() -- 獲得類的所有公共字段
Field getDeclaredField(String name) -- 獲得類聲明的命名的字段
Field[] getDeclaredFields() -- 獲得類聲明的所有字段	
           

4.7調用方法

（1）獲得方法資訊的方法

Method getMethod(String name, Class[] params) -- 使用特定的參數類型，獲得命名的公共方法
Method[] getMethods() -- 獲得類的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特寫的參數類型，獲得類聲明的命名的方法
Method[] getDeclaredMethods() -- 獲得類聲明的所有方法
           

（2）當我們從類中擷取了一個方法後，我們就可以用 invoke() 方法來調用這個方法。invoke 方法的原型為:

4.8利用反射建立數組

（1）數組在Java裡是比較特殊的一種類型，它可以指派給一個Object Reference 其中的Array類為

java.lang.reflect.Array類。

（2）我們通過Array.newInstance()建立數組對象，它的原型是:

public static Object newInstance(Class<?> componentType, int length);

           

4.9反射擷取泛型真實類型

（1）當我們對一個泛型類進行反射時，需要得到泛型中的真實資料類型，來完成如json反序列化的操作。此時需要通過Type 體系來完成。Type 接口包含了一個實作類(Class)和四個實作接口，他們分别是：

• TypeVariable

  泛型類型變量。可以泛型上下限等資訊；

• ParameterizedType

  具體的泛型類型，可以獲得中繼資料中泛型簽名類型(泛型真實類型)

• GenericArrayType

  當需要描述的類型是泛型類的數組時，比如List[],Map[]，此接口會作為Type的實作。

• WildcardType

  通配符泛型，獲得上下限資訊；

4.9.1TypeVariable

package com.annotations.class1.test;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

public class TestType <K extends Comparable & Serializable,V> {
    K key;
    V value;

    public static void main(String[] args) throws NoSuchFieldException {
        //s1.擷取字段類型
        Field fk = TestType.class.getDeclaredField("key");
        Field fv = TestType.class.getDeclaredField("value");

        //s2.擷取泛型類型
        TypeVariable keyType = (TypeVariable) fk.getGenericType();
        TypeVariable valueType = (TypeVariable) fv.getGenericType();

        //s3.getName列印變量名
        System.out.println(keyType.getName());
        System.out.println(valueType.getName());

        //s4.getGenericDeclaration擷取泛型聲明
        System.out.println(keyType.getGenericDeclaration());
        System.out.println(valueType.getGenericDeclaration());

        //s5.getBounds()方法
        System.out.println("K的上界:");
        for(Type type : keyType.getBounds()){
            System.out.println(type);
        }

        System.out.println("V的上界:");
        for(Type type : valueType.getBounds()){
            System.out.println(type);
        }
    }
}

           

運作結果:

K
V
class com.annotations.class1.test.TestType
class com.annotations.class1.test.TestType
K的上界:
interface java.lang.Comparable
interface java.io.Serializable
V的上界:
class java.lang.Object
           

4.9.2ParameterizedType

（1）案例

package com.annotations.class1.test;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;

public class TestType1 {
    Map<String,String> map;

    public static void main(String[] args) throws Exception {
        //s1.擷取指定字段
        Field field = TestType1.class.getDeclaredField("map");
        //s2.輸出字段的泛型類型
        System.out.println(field.getGenericType());
        //s3.擷取字段的泛型類型
        ParameterizedType pType = (ParameterizedType) field.getGenericType();
        //s4.擷取泛型類型的實際類型
        System.out.println(pType.getRawType());
        //s5.擷取字段的泛型類型的參數類型
        for(Type type : pType.getActualTypeArguments()){
            System.out.println(type);
        }
    }
}
           

（2）運作結果

java.util.Map<java.lang.String, java.lang.String>
interface java.util.Map
class java.lang.String
class java.lang.String
           

4.9.3GenericArrayType

（1）案例

package com.annotations.class1.test;

import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.util.List;

public class TestType2<T> {

    List<String>[] lists;

    public static void main(String[] args) throws NoSuchFieldException {
        //s1.擷取字段
        Field f = TestType2.class.getDeclaredField("lists");
        //s2.擷取泛型數組類型
        GenericArrayType genericArrayType = (GenericArrayType) f.getGenericType();
        //s3.擷取泛型數組元素類型
        System.out.println(genericArrayType.getGenericComponentType());
    }
}
           

（2）運作結果

4.9.4WildcardType

（1）案例代碼

package com.annotations.class1.test;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.WildcardType;
import java.util.List;

public class TestType3 {
    //s1.泛型上界限定
    private List<? extends Number> a;

    //s2.泛型下界限定
    private List<? super Number> b;

    public static void main(String[] args) throws NoSuchFieldException {
        //s1.得到字段
        Field fieldA = TestType3.class.getDeclaredField("a");
        Field fieldB = TestType3.class.getDeclaredField("b");

        //s2.擷取泛型類型
        ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType();
        ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType();

        //s3.從泛型中拿到通配符類型
        WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
        WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0];

        //s4.測試方法
        System.out.println(wTypeA.getUpperBounds()[0]);
        System.out.println(wTypeB.getLowerBounds()[0]);

        //s5.檢視通配符類型到底是什麼
        System.out.println(wTypeA);

    }
}
           

（2）運作結果

class java.lang.Number
class java.lang.Number
? extends java.lang.Number
           

4.9.5Gson反序列化

static class Response<T> {
    T data;
    int code;
    String message;
    
    @Override
    public String toString() {
        return "Response{" +
        "data=" + data +
        ", code=" + code +
        ", message='" + message + '\'' +
        '}';
    }
    
    public Response(T data, int code, String message) {
        this.data = data;
        this.code = code;
        this.message = message;
    }
}

static class Data {
	String result;
	
    public Data(String result) {
        this.result = result;
    }
    
    @Override
    public String toString() {
        return "Data{" +
        "result=" + result +
        '}';
    }
}

public static void main(String[] args) {
	Response<Data> dataResponse = new Response(new Data("資料"), 1, "成功");
    Gson gson = new Gson();
    String json = gson.toJson(dataResponse);
    System.out.println(json);

//為什麼TypeToken要定義為抽象類？
    Response<Data> resp = gson.fromJson(json, new TypeToken<Response<Data>>() {
    }.getType());
	System.out.println(resp.data.result);
}

           

（1）在進行GSON反序列化時，存在泛型時，可以借助TypeToken 擷取Type以完成泛型的反序列化。但是為什麼TypeToken 要被定義為抽象類呢？

（2）因為隻有定義為抽象類或者接口，這樣在使用時，需要建立對應的實作類，此時确定泛型類型，編譯才能夠将泛型signature資訊記錄到Class中繼資料中。

5.打賞鼓勵

感謝您的細心閱讀，您的鼓勵是我寫作的不竭動力！！！

5.1微信打賞

5.2支付寶打賞