使用yield進行非同步流程控制

阿新 • • 發佈：2022-05-04

註解和反射

註解

Java.Annotation

Annotation是從JDK5.0開始引入的新技術。
Annotation的作用：
- 不是程式本身，可以對程式作出解釋。（這一點和註釋(Comment)沒什麼區別）
- 可以被其他程式（比如：編譯器等）讀取。
Annotation的格式：

註解是以"@註釋名"在程式碼中存在的，還可以新增一些引數值，例如：@SuppressWarnings(value="unchecked")。

Annotation在哪裡使用？

可以附加在package,class,method,field等上面，相當於給它們添加了額外的輔助資訊，我們可以通過反射機制程式設計實現對這些元資料的訪問。

內建註解

@Override：定義在java.lang.Override中，此註解只適用於修飾方法，表示一個方法宣告打算重寫超類中的另一個方法宣告。
@Deprecated：定義在java.lang.Deprecated中，此註解可以用於修飾方法、屬性、類，表示不鼓勵程式設計師使用這樣的元素，通常是因為它很危險或者存在更好的選擇。
@SuppressWarnings：定義在java.lang.SuppressWarnings中，用來抑制編譯時的警告資訊。
- 與前兩個註解有所不同，你需要新增一個引數才能正確使用，這些引數都是已經定義好了的。
  - @SuppressWarnings("all")
  - @SuppressWarnings("unchecked")
  - @SuppressWarnings(value={"unchecked","deprecation"})
  - 等等...

 1 package com.annotation;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 // 什麼是註解
 7 public class Test01 extends Object{
 8     @Override  // 重寫的註解
 9     public String toString() {
 
10         return super.toString();
11     }
12 
13     @Deprecated  // 不推薦程式設計師使用，存在危險或有更好的方式
14     public static void test() {
15         System.out.println("Deprecated");
16     }
17 
18     @SuppressWarnings("all")  // 鎮壓警告
19     public void test1() {
20         List list = new ArrayList();
21     }
22 
23     public static void main(String[] args) {
24         test();
25     }
26 }

元註解

元註解的作用就是負責註解其他註解，Java定義了4個標準的meta-annotation型別，它們被用來提供對其他annotation型別做說明。
這些型別和它們所支援的類在java.lang.annotation包中可以找到。(@Target，@Retention，@Documented，@Inherited)
- @Target：用於描述註解的使用範圍（即：被描述的註解可以用在什麼地方）
- @Retention：表示需要在什麼級別儲存該註解資訊，用於描述註解的生命週期
  - （SOURCE < CLASS < RUNTIME）
- @Document：說明該註解被包含在javadoc中
- @Inherited：說明子類可以繼承父類中的該註解

 1 package com.annotation;
 2 
 3 import java.lang.annotation.*;
 4 
 5 // 元註解的使用
 6 public class Test02 {
 7 }
 8 
 9 // 定義一個註解
10 // Target  表示我們的註解可以用在哪些地方。
11 @Target(value = {ElementType.METHOD,ElementType.TYPE})
12 
13 // Retention  表示我們的註解在什麼地方還有效。
14 // Runtime > Class > Sources
15 @Retention(value = RetentionPolicy.RUNTIME)
16 
17 // Documented  表示是否將我們的註解生成在JAVAdoc中
18 @Documented
19 
20 // Inherited  子類可以繼承父類的註解
21 @Inherited
22 @interface MyAnnotation {
23 
24 }

自定義註解

使用@interface自定義註解時，自動繼承了java.lang.annotation.Annotation介面
分析：
- @interface用來宣告一個註解，格式：public @interface 註解名 { 定義內容 }
- 其中的每一個方法實際上是聲明瞭一個配置引數。
- 方法的名稱就是引數的名稱。
- 返回值型別就是引數的型別（返回值只能是基本型別，Class, String, enum ）。
- 可以通過default來宣告引數的預設值
- 如果只有一個引數成員，一般引數名為value
- 註解元素必須要有值，我們定義註解元素時，經常使用空字串，0作為預設值。

 1 package com.annotation;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 // 自定義註解
 9 public class Test03 {
10     
11     @MyAnnotation1(name = "傑瑞",age = 17)
12     public void test() {
13         
14     }
15     
16     @MyAnnotation2("JAVA")
17     public void test1() {
18         
19     }
20 }
21 
22 @Target({ElementType.TYPE,ElementType.METHOD})
23 @Retention(RetentionPolicy.RUNTIME)
24 @interface MyAnnotation1 {
25     // 註解的引數：引數型別 + 變數名()
26     String name() default "湯姆";
27     int age() default 18;
28     int id() default -1;  // 如果預設值為-1，代表不存在
29     String[] schools() default {"清華，北大"}; 
30 }
31 
32 @Target({ElementType.TYPE,ElementType.METHOD})
33 @Retention(RetentionPolicy.RUNTIME)
34 @interface MyAnnotation2 {
35     String value();  // 引數名為value時，使用該註解時便不需要寫value引數名
36 }

反射

Java.Reflection

靜態 VS 動態語言

動態語言
- 是一類在執行時可以改變其結構的語言：例如新的函式、物件、甚至程式碼可以被引進，已有的函式可以被刪除或是其他結構上的變化。通俗點說就是在執行時程式碼根據某些條件改變自身結構。
- 主要動態語言：Object-C、C#、JavaScript、PHP、Python等。
靜態語言
- 與動態語言相對應的，執行時結構不可變的語言就是靜態語言。如Java、C、C++。
- Java不是動態語言，但Java可以稱之為 “準動態語言” 。即Java有一定的動態性，我們可以利用反射機制獲得類似動態語言的特性。Java的動態性讓程式設計的時候更加靈活！
Reflection（反射）是Java被視為動態語言的關鍵，反射機制允許程式在執行期藉助Reflection API取得任何類的內部資訊，並能直接操作任意物件的內部屬性及方法。
載入完類之後，在堆記憶體的方法區就產生了一個Class型別的物件（一個類只有一個Class物件），這個物件就包含了完整的類的結構資訊。我們可以通過這個物件看到類的結構。這個物件就像一面鏡子，透過這個鏡子看到類的結構，所以，我們形象的稱之為：反射

Java反射優點和缺點：

優點：可以實現動態建立物件和編譯，體現出很大的靈活性
缺點：對效能有影響。使用反射基本上是一種解釋操作，我們可以告訴JVM，我們希望做什麼並且它滿足我們的要求。這類操作總是慢於直接執行相同的操作。

反射相關的API：

java.lang.Class: 代表一個類
java.lang.reflect.Method: 代表類的方法
java.lang.reflect.Field 代表類的成員變數
java.lang.reflect.Constructor: 代表類的構造器

Class類

物件照鏡子後可以得到的資訊：某個類的屬性、方法和構造器、某個類到底實現了哪些介面。對於每個類而言，JRE都為其保留一個不變的Class型別的物件。一個Class物件包含了特定某個結構(class/interface/enum/annotation/primitive type/void/[])的有關資訊。

Class本身也是一個類
Class物件只能由系統建立物件
一個載入的類在 JVM中只會有一個Class例項
一個Class物件對應的是一個載入到 JVM中的一個 .class檔案
每個類的例項都會記得自己是由哪個Class例項所生成
通過Class可以完整地得到一個類中所有被載入的結構
Class類是Reflection的根源，針對任何你想動態載入、執行的類，唯有先獲得相應的Class物件

獲取Class類的例項

若已知具體的類，通過類的class屬性獲取，該方法最為安全可靠，程式效能最高。
已知某個類的例項，呼叫該例項的getClass()方法獲取Class物件
已知一個類的全類名，且該類就在類路徑下，可通過Class類的靜態方法forName()獲取，可能丟擲ClassNotFoundException
內建基本資料型別可以直接用類名.Type
利用ClassLoader

 1 package com.reflection;
 2 
 3 // 建立Class類的物件
 4 public class demo01 {
 5     public static void main(String[] args) {
 6         Person person = new Student();
 7         System.out.println("這個人是：" + person.name);
 8 
 9         // 方式一：通過類的物件獲得
10         Class c1 = person.getClass();
11         System.out.println(c1.hashCode());
12 
13         // 方式二：使用Class.forName()方法
14         try {
15             Class c2 = Class.forName("com.reflection.Person");
16             System.out.println(c2.hashCode());
17         } catch (ClassNotFoundException e) {
18             e.printStackTrace();
19         }
20 
21         // 方式三：通過類名.class獲得
22         Class c3 = Person.class;
23         System.out.println(c3.hashCode());
24 
25         // 方式四：基本內建型別的包裝類都有一個TYPE屬性
26         Class c4 = Integer.TYPE;
27         System.out.println("c4：" + c4.hashCode());
28 
29         // 獲得父類型別
30         Class c5 = c1.getSuperclass();
31         System.out.println(c5);
32         System.out.println(c5.hashCode());
33     }
34 }
35 
36 class Person {
37     String name;
38 
39     public Person() {
40 
41     }
42 
43     public Person(String name) {
44         this.name = name;
45     }
46 }
47 
48 class Student extends Person {
49     public Student() {
50         this.name = "學生";
51     }
52 }

哪些型別可以有Class物件：

class：外部類，成員(成員內部類，靜態內部類)，區域性內部類，匿名內部類。
interface：介面
[] ：陣列
enum：列舉
annotation：註解@interface
primitive type：基本資料型別
void

 1 package com.reflection;
 2 
 3 import java.lang.annotation.ElementType;
 4 
 5 // 所有型別的Class物件
 6 public class Demo02 {
 7     public static void main(String[] args) {
 8         Class c1 = Object.class;  // 類
 9         Class c2 = Comparable.class;  // 介面
10         Class c3 = String[].class;  // 一維陣列
11         Class c4 = int[][].class;  // 二維陣列
12         Class c5 = Override.class;  // 註解
13         Class c6 = ElementType.class;  // 列舉
14         Class c7 = Integer.class;  // 基本資料型別
15         Class c8 = void.class;  // void
16         Class c9 = Class.class; // Class
17 
18         System.out.println(c1);
19         System.out.println(c2);
20         System.out.println(c3);
21         System.out.println(c4);
22         System.out.println(c5);
23         System.out.println(c6);
24         System.out.println(c7);
25         System.out.println(c8);
26         System.out.println(c9);
27 
28         // 只要元素型別與維度一樣，就是同一個Class物件
29         int[] a = new int[10];
30         int[] b = new int[100];
31         System.out.println(a.getClass().hashCode());
32         System.out.println(b.getClass().hashCode());
33 
34     }
35 }

類的載入過程

當程式主動使用某個類時，如果該類還未被載入到記憶體中，則系統會通過如下三個步驟來對該類進行初始化。

類的載入與ClassLoader的理解

載入：將class檔案位元組碼內容載入到記憶體中，並將這些靜態資料轉換成方法區的執行時資料結構，然後生成一個代表這個類的java.lang.Class物件。
連結：將Java類的二進位制程式碼合併到JVM的執行狀態之中的過程。
- 驗證：確保載入的類資訊符合JVM規範，沒有安全方面的問題
- 準備：正式為類變數（static）分配記憶體並設定類變數預設初始值的階段，這些記憶體都將在方法區中進行分配
- 解析：虛擬機器常量池內的符號引用（常量名）替換為直接引用（地址）的過程。
初始化：
- 執行類構造器<clinit>() 方法的過程。類構造器<clinit>() 方法是由編譯期自動收集類中所有類變數的賦值動作和靜態程式碼塊中的語句合併產生的。（類構造器是構造類資訊的，不是構造該類物件的構造器）。
- 當初始化一個類的時候，如果發現其父類還沒有進行初始化，則需要先觸發其父類的初始化。
- 虛擬機器會保證一個類的<clinit>() 方法在多執行緒環境中被正確加鎖和同步。

 1 package com.reflection;
 2 
 3 public class Demo033 {
 4     public static void main(String[] args) {
 5         A a = new A();
 6         System.out.println(A.m);
 7 
 8         /*
 9         1. 載入到記憶體，會產生一個類對應Class物件
10         2. 連結，連結結束後 m = 0
11         3. 初始化
12                 <clinit>() {
13                         static int m = 100;
14                         System.out.println("A類靜態程式碼塊初始化");
15                         m = 300;
16                         System.out.println("A類構造方法初始化");
17                         m = 200;
18                 }
19          */
20     }
21 }
22 
23 class A {
24     static int m = 100;
25 
26     static {
27         System.out.println("A類靜態程式碼塊初始化");
28         m = 300;
29     }
30 
31     public A() {
32         System.out.println("A類構造方法初始化");
33         m = 200;
34     }
35 }

類載入器

類載入器的作用：將class檔案位元組碼內容載入到記憶體中，並將這些靜態資料轉換成方法區的執行時資料結構，然後在堆中生成一個代表這個類的java.lang.Class物件，作為方法區中類資料的訪問入口。
類快取：標準的JavaSE類載入器可以按照要求查詢類，但一旦某個類被載入到類載入器中，它將維持載入（快取）一段時間。不過JVM垃圾回收機制可以回收這些Class物件。

類載入器的作用：

類載入器作用是把類(class)裝載進記憶體的。JVM規範定義瞭如下型別的載入器。

引導載入器：用C++編寫的，是JVM自帶的類載入器，負責Java平臺核心庫，用來裝載核心類庫。該載入器無法直接獲取
擴充套件類載入器：負責jre/lib/ext目錄下的jar包或 - D java.ext.path所指的目錄下的類與jar包裝入工作，是最常用的載入器

 1 package com.reflection;
 2 
 3 // 獲取類載入器
 4 public class Demo04 {
 5     public static void main(String[] args) throws ClassNotFoundException {
 6 
 7         // 獲取系統類的載入器
 8         ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
 9         System.out.println(systemClassLoader);
10 
11         // 獲取系統類載入器的父類載入器 --> 擴充套件類載入器
12         ClassLoader parent = systemClassLoader.getParent();
13         System.out.println(parent);
14 
15         // 獲取擴充套件類載入器的父類載入器 --> 根載入器(C/C++) 無法直接獲取
16         ClassLoader parent1 = parent.getParent();
17         System.out.println(parent1);
18 
19         // 測試當前類是哪個載入器載入的
20         ClassLoader classLoader = Class.forName("com.reflection.Demo04").getClassLoader();
21         System.out.println(classLoader);
22 
23         // 測試JDK內建的類是誰載入的
24         ClassLoader classLoader1 = Class.forName("java.lang.String").getClassLoader();
25         System.out.println(classLoader1);
26 
27         // 如何獲得系統類載入器可以載入的路徑
28         System.out.println(System.getProperty("java.class.path"));
29         
30         /*
31         C:\Program Files\java\jdk1.8.0_65\jre\lib\charsets.jar;
32         C:\Program Files\java\jdk1.8.0_65\jre\lib\deploy.jar;
33         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\access-bridge-64.jar;
34         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\cldrdata.jar;
35         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\dnsns.jar;
36         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\jaccess.jar;
37         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\jfxrt.jar;
38         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\localedata.jar;
39         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\nashorn.jar;
40         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\sunec.jar;
41         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\sunjce_provider.jar;
42         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\sunmscapi.jar;
43         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\sunpkcs11.jar;
44         C:\Program Files\java\jdk1.8.0_65\jre\lib\ext\zipfs.jar;
45         C:\Program Files\java\jdk1.8.0_65\jre\lib\javaws.jar;
46         C:\Program Files\java\jdk1.8.0_65\jre\lib\jce.jar;
47         C:\Program Files\java\jdk1.8.0_65\jre\lib\jfr.jar;
48         C:\Program Files\java\jdk1.8.0_65\jre\lib\jfxswt.jar;
49         C:\Program Files\java\jdk1.8.0_65\jre\lib\jsse.jar;
50         C:\Program Files\java\jdk1.8.0_65\jre\lib\management-agent.jar;
51         C:\Program Files\java\jdk1.8.0_65\jre\lib\plugin.jar;
52         C:\Program Files\java\jdk1.8.0_65\jre\lib\resources.jar;
53         C:\Program Files\java\jdk1.8.0_65\jre\lib\rt.jar;
54         D:\JavaSE\out\production\basic;D:\JavaSE\basic\lib\c3p0-0.9.5.2.jar;
55         D:\JavaSE\basic\lib\commons-io-2.2.jar;
56         D:\JavaSE\basic\lib\commons-dbcp-1.4.jar;
57         D:\JavaSE\basic\lib\commons-pool-1.6.jar;
58         D:\JavaSE\basic\lib\mchange-commons-java-0.2.11.jar;
59         D:\JavaSE\basic\lib\mysql-connector-java-8.0.18.jar;
60         C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2021.1.2\lib\idea_rt.jar
61          */
62 
63     }
64 }

建立執行時類的物件

獲取執行時類的完整結構

通過反射獲取執行時類的完整結構

Field、Method、Constructor、Superclass、Interface、Annotation

實現的全部介面
所繼承的父類
全部的構造器
全部的方法
全部的Field
註解
......

 1 package com.reflection;
 2 
 3 import com.sun.org.apache.xerces.internal.impl.xpath.XPath;
 4 
 5 import java.lang.reflect.Constructor;
 6 import java.lang.reflect.Field;
 7 import java.lang.reflect.Method;
 8 
 9 // 獲得執行時類的物件
10 public class Demo05 {
11     public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
12         User user = new User();
13         Class c1 = user.getClass();
14 
15         // 獲得類的名字
16         System.out.println(c1.getName());  // 獲得 包名 + 類名
17         System.out.println(c1.getSimpleName());  // 獲得 類名
18 
19         // 獲得類的屬性
20         System.out.println();
21         Field[] fields = c1.getFields();  // 獲得所有public屬性
22         System.out.println("=====getFields()=====");
23         for (Field field : fields) {
24             System.out.println(field);
25         }
26 
27         System.out.println();
28         System.out.println("=====getDeclaredFields()=====");
29         Field[] declaredFields = c1.getDeclaredFields();  // 獲得類的全部屬性
30         for (Field declaredField : declaredFields) {
31             System.out.println(declaredField);
32         }
33 
34         // 獲得指定屬性的值
35         System.out.println("獲得指定屬性的值");
36         Field name = c1.getDeclaredField("name");
37         System.out.println(name);
38 
39         // 獲得類的方法
40         System.out.println();
41         System.out.println("=====getMethods()=====");
42         Method[] methods = c1.getMethods();  // 獲得本類和父類的所有public方法
43         for (Method method : methods) {
44             System.out.println(method);
45         }
46 
47         System.out.println();
48         System.out.println("=====getDeclaredMethods()=====");
49         Method[] declaredMethods = c1.getDeclaredMethods();  // 獲得本類的所有方法
50         for (Method declaredMethod : declaredMethods) {
51             System.out.println(declaredMethod);
52         }
53 
54         // 獲得指定方法
55         // 為什麼要加入引數型別，因為方法的過載
56         System.out.println();
57         System.out.println("獲得指定方法");
58         Method setName = c1.getMethod("setName", String.class);
59         System.out.println(setName);
60         Method getName = c1.getMethod("getName",null);
61         System.out.println(getName);
62 
63         // 獲得構造器
64         System.out.println();
65         System.out.println("獲得構造器");
66         Constructor[] constructors = c1.getConstructors();
67         for (Constructor constructor : constructors) {
68             System.out.println(constructor);
69         }
70 
71         // 獲得指定的構造器
72         System.out.println("獲得指定的構造器");
73         Constructor constructor = c1.getConstructor(String.class, int.class);
74         System.out.println(constructor);
75 
76         // 獲得類的載入器
77         System.out.println();
78         System.out.println("獲得類的載入器");
79         ClassLoader classLoader = c1.getClassLoader();
80         System.out.println(classLoader);
81 
82     }
83 }

操作Class物件

建立類的物件：呼叫Class物件的newInstance() 方法
- 類必須有一個無引數的構造器
- 類的構造器的訪問許可權需要足夠
沒有無參構造器時建立類的物件：
- 通過Class類的getDeclaredConstructor(Class ... parameterTypes) 取得本類的指定形參型別的構造器
- 向構造器的形參中傳遞一個物件陣列進去，裡面包含了構造器中所需要的各個引數
- 通過Constructor例項化物件
呼叫指定的方法：
- 通過反射，呼叫類中的方法，通過Method類完成。
- 通過Class類的getMethod(String name, Class ... parameterTypes)方法取得一個Method物件，並設定此方法操作時所需要的型別。
- 之後使用Object invoke(Object obj, Object[] args) 進行呼叫，並向方法中傳遞要設定的obj物件的引數資訊。
Object invoke(Object obj, Object ... args)
- Object對應原方法的返回值，若原方法無返回值，此時返回null
- 若原方法為靜態方法，此時形參Object obj可為null
- 若原方法形參列表為空，則Object[] args為null
- 若原方法宣告為private，則需要在呼叫此invoke() 方法前，顯示呼叫方法物件的setAccessible(true)方法，將可訪問private的方法
setAccessible
- Method和Field、Constructor物件都有setAccessible() 方法。
- setAccessible作用是啟動和禁用訪問安全檢查的開關。
- 引數為true則指示反射的物件在使用時應該取消Java語言訪問檢查。
  - 提高反射的效率。如果程式碼中必須用反射，而該句程式碼需要頻繁地被呼叫，那麼請設定為true
  - 使得原本無法訪問的私有成員也可以被訪問
- 引數值為false則指示反射的物件應該實施Java語言訪問檢查

效能對比分析

 1 package com.reflection;
 2 
 3 import java.lang.reflect.InvocationTargetException;
 4 import java.lang.reflect.Method;
 5 
 6 // 效能對比分析
 7 public class Demo07 {
 8 
 9     // 普通方式呼叫
10     public static void test01() {
11         User user = new User();
12 
13         long startTime = System.currentTimeMillis();
14 
15         for (int i = 0; i < 1000000000; i++) {
16             user.getName();
17         }
18 
19         long endTime = System.currentTimeMillis();
20 
21         System.out.println("普通方式執行10億次：" + (endTime-startTime) + "ms");
22     }
23 
24     // 反射方式呼叫
25     public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
26         User user = new User();
27         Class c1 = user.getClass();
28         Method getName = c1.getDeclaredMethod("getName", null);
29 
30         long startTime = System.currentTimeMillis();
31 
32         for (int i = 0; i < 1000000000; i++) {
33             getName.invoke(user,null);
34         }
35 
36         long endTime = System.currentTimeMillis();
37 
38         System.out.println("反射方式執行10億次：" + (endTime-startTime) + "ms");
39     }
40 
41     // 反射方式呼叫 關閉檢測
42     public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
43         User user = new User();
44         Class c1 = user.getClass();
45         Method getName = c1.getDeclaredMethod("getName", null);
46         getName.setAccessible(true);
47 
48         long startTime = System.currentTimeMillis();
49 
50         for (int i = 0; i < 1000000000; i++) {
51             getName.invoke(user,null);
52         }
53 
54         long endTime = System.currentTimeMillis();
55 
56         System.out.println("關閉檢測執行10億次：" + (endTime-startTime) + "ms");
57     }
58 
59     public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
60         test01();
61         test02();
62         test03();
63 
64         /*
65         普通方式執行10億次：3ms
66         反射方式執行10億次：1143ms
67         關閉檢測執行10億次：848ms
68          */
69     }
70 }

反射操作泛型

Java採用泛型擦除的機制來引入泛型，Java中的泛型僅僅是給編譯器javac使用的，確保資料的安全性和免去強制型別轉換問題，但是，一旦編譯完成，所有和泛型有關的型別全部擦除
為了通過反射操作這些型別，Java新增了ParameterizedType，GenericArrayType,TypeVariable 和 WildcardType 幾種型別來代表不能被歸一到Class類中的型別但是又和原始型別齊名的型別。
ParameterizedType：表示一種引數化型別，比如Collection<String>
GenericArrayType：表示一種元素型別是引數化型別或者型別變數的陣列型別
TypeVariable：是各種型別變數的公共父介面
WildcardType：代表一種萬用字元型別表示式

 1 package com.reflection;
 2 
 3 import java.lang.reflect.Method;
 4 import java.lang.reflect.ParameterizedType;
 5 import java.lang.reflect.Type;
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 // 通過反射獲取泛型
10 public class Demo08 {
11 
12     public void test01(Map<String,User> map, List<User> list) {
13         System.out.println("test01");
14     }
15 
16     public Map<String,User> test02() {
17         System.out.println("test02");
18         return null;
19     }
20 
21     public static void main(String[] args) throws NoSuchMethodException {
22         Method method = Demo08.class.getMethod("test01", Map.class, List.class);
23         Type[] genericParameterTypes = method.getGenericParameterTypes();
24         for (Type genericParameterType : genericParameterTypes) {
25             System.out.println("###" + genericParameterType);
26             if (genericParameterType instanceof ParameterizedType) {
27                 Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
28                 for (Type actualTypeArgument : actualTypeArguments) {
29                     System.out.println(actualTypeArgument);
30                 }
31             }
32         }
33 
34         method = Demo08.class.getMethod("test02", null);
35         Type genericReturnType = method.getGenericReturnType();
36 
37         System.out.println("###" + genericReturnType);
38         if (genericReturnType instanceof ParameterizedType) {
39             Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
40             for (Type actualTypeArgument : actualTypeArguments) {
41                 System.out.println(actualTypeArgument);
42             }
43         }
44     }
45 }

反射操作註解

ORM：Object relationShip Mapping --> 物件對映關係

類和表結構對應
屬性和欄位對應
物件和記錄對應

練習要求：利用註解和反射完成類和表結構的對映關係

 1 package com.reflection;
 2 
 3 import java.lang.annotation.*;
 4 import java.lang.reflect.Field;
 5 
 6 // 練習反射操作註解
 7 public class Demo09 {
 8     public static void main(String[] args) throws NoSuchFieldException {
 9         Class c1 = Student1.class;
10         Annotation[] annotations = c1.getAnnotations();
11         for (Annotation annotation : annotations) {
12             System.out.println(annotation);
13         }
14 
15         // 獲得註解的value值
16         Test test = (Test)c1.getAnnotation(Test.class);
17         String value = test.value();
18         System.out.println(value);
19 
20         // 獲得類指定的註解
21         Field field = c1.getDeclaredField("name");
22         TestFiled annotation = field.getAnnotation(TestFiled.class);
23         System.out.println(annotation.columnName());
24         System.out.println(annotation.type());
25         System.out.println(annotation.length());
26 
27     }
28 }
29 
30 @Test("db_Student")
31 class Student1 {
32     @TestFiled(columnName = "db_id",type = "int",length = 10)
33     private int id;
34     @TestFiled(columnName = "db_name",type = "varchar",length = 3)
35     private String name;
36     @TestFiled(columnName = "db_age",type = "int",length = 10)
37     private int age;
38 
39     public Student1() {
40     }
41 
42     public Student1(int id, String name, int age) {
43         this.id = id;
44         this.name = name;
45         this.age = age;
46     }
47 
48     public int getId() {
49         return id;
50     }
51 
52     public void setId(int id) {
53         this.id = id;
54     }
55 
56     public String getName() {
57         return name;
58     }
59 
60     public void setName(String name) {
61         this.name = name;
62     }
63 
64     public int getAge() {
65         return age;
66     }
67 
68     public void setAge(int age) {
69         this.age = age;
70     }
71 
72     @Override
73     public String toString() {
74         return "Student1{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}';
75     }
76 }
77 
78 // 定義類名的註解
79 @Target(ElementType.TYPE)
80 @Retention(RetentionPolicy.RUNTIME)
81 @interface Test {
82     String value();
83 }
84 
85 // 定義屬性的註解
86 @Target(ElementType.FIELD)
87 @Retention(RetentionPolicy.RUNTIME)
88 @interface TestFiled {
89     String columnName();
90     String type();
91     int length();
92 }