一、泛型的概念
1、基礎案例
泛型在Java中的應用非常廣泛，最常見則是在集合容器中，先看下基礎用法：
public class Generic01 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<>() ;
map.put(88,"hello") ;
// map.put("99","world") ; 輸入編譯錯誤
String value = map.get(88) ;
// Integer value = map.get(88) ; 輸出編譯錯誤
System.out.println("value:"+value);
}
}
聲明一個map類型的容器，並且明確限定key和value的類型：分別為Integer,String，這樣顯然不能體現特別之處，可以對比下面的用法：
Map newMap = new HashMap() ;
newMap.put("hello","world");
newMap.put(88,99);
在不指定類型的情況下，鍵值對都默認為Object類型，這樣的容器在使用的時候要時刻注意不同的key類型和取出的value值類型，並且value要做類型轉換，相比之下泛型機制就很有必要。
可以看下Map接口的定義：
public interface Map<K,V> {
V get(Object key);
V put(K key, V value);
}
在Map接口中，<K,V>顯然沒有指定明確的類型，只是起到類型傳遞的作用，即K是key的類型，V是value的類型，在上面的源碼中描述的很清楚，結合上面案例，在Map對象聲明的時候可以明確指定<K,V>的類型，也可以缺省為Object類型。
2、泛型描述
泛型即可以理解為把數據類型作為參數，即參數化類型，用來提高代碼的安全性，靈活性，避免類型轉換；代碼簡潔明了，同時對於程序的可擴展性起到至關重要的作用。
首先設計一個簡單的頂層接口，只定義一個callBack方法，和對出入參數的簡單邏輯設定，這種設計在Java的源碼設計中隨處可見，例如上面的集合體系：
/**
* 基礎接口設計
* @param <R> 返參類型
* @param <V> 入參類型
*/
interface CallBack<R,V> {
/**
* 回調方法：V 方法入參 ，R 方法返回值
*/
R callBack (V v) ;
}
為了實現具體的業務，再基於頂層接口向下做擴展，這里聲明兩個擴展接口，作為具體業務類的接口：
/**
* 擴展接口設計01
*/
interface ExtCallBack01<R extends Integer,V extends List<String>>
extends CallBack<Integer,List<String>> {
@Override
Integer callBack (List<String> list) ;
}
/**
* 擴展接口設計01
*/
interface ExtCallBack02<R extends Boolean,V extends Map<String,Long>>
extends CallBack<Boolean,Map<String,Long>> {
@Override
Boolean callBack (Map<String,Long> map) ;
}
這樣可以通過擴展接口去設計具體的業務類，提高程序的靈活可擴展性：
public class Generic02 {
public static void main(String[] args) {
new ExtCallBack01<Integer,List<String>>(){
@Override
public Integer callBack(List<String> list) {
list.add("hello");
return list.size();
}
};
new ExtCallBack02<Boolean,Map<String,Long>> (){
@Override
public Boolean callBack(Map<String, Long> map) {
map.put("Fire",119L) ;
return map.size()>0 ;
}
} ;
}
}
通過上面這個案例，可以清楚的感覺到泛型機制的靈活和強大。
3、泛型本質
泛型雖然可以使用在類，接口，方法，參數等各個地方，但是其約束能力是在代碼的編譯期：
public class Generic03 {
public static void main(String[] args) {
DefEntry<String> defEntry1 = new DefEntry<>("hello") ;
DefEntry<Long> defEntry2 = new DefEntry<>(999L) ;
// Always True
System.out.println(defEntry1.getClass()==defEntry2.getClass());
}
}
class DefEntry<T> {
private T param ;
public DefEntry (T param){
this.param = param ;
}
}
編譯過程中，會對泛型合法性作校驗，校驗成功編譯的class文件沒有泛型信息，即泛型擦除掉，通過一個簡單的命令查看編譯后的文件：
javap -v Generic03.class
當然這也會帶來安全問題：
public static void main(String[] args) throws Exception {
Map<String, String> map = new HashMap<>();
Method method = HashMap.class.getDeclaredMethod("put",
new Class[] { Object.class, Object.class });
method.invoke(map,888L, 999L);
// {888=999}
System.out.println(map);
// java.lang.ClassCastException
System.out.println(map.get(888L));
}
這里即通過反射的機制，繞開泛型，在map中放入程序語義上的非法值類型，在運行過程中獲取值的時候才拋出類型轉換異常。
二、反射機制
1、基礎描述
反射機制可以在程序運行時獲取類的完整結構信息，並且可以動態的操作屬性和方法等。
對於反射機制的理解，必須要對類編譯和JVM加載，運行時數據區有清楚的認識，這塊內容可以移步JVM系列的文章。
通過運行時動態獲取類的結構，然后動態的創建對象並操作屬性和方法，這種方式在實際開發中並不多用，這樣很明顯會消耗JVM資源，並且會忽略一些封裝導致安全問題，這在上面【1】中已經案例說明了。
2、反射的類庫
- java.lang.Class：Class類
- java.lang.reflect.Constructor：構造器
- java.lang.reflect.Field：屬性
- java.lang.reflect.Method：方法
API之Class對象
獲取目標類型的Class對象常見方式，通過Class對象再獲取相關結構信息，從而操作或者訪問：
public static void main(String[] args) throws Exception {
// Class對象回去
User user1 = new User(1,"name01") ;
Class userClass1 = user1.getClass() ;
Class userClass2 = Class.forName("com.java.reflect.User");
Class userClass3 = User.class ;
System.out.println(User.class.getName());
System.out.println("userClass1==userClass2?"+(userClass1==userClass2));
System.out.println("userClass2==userClass3?"+(userClass2==userClass3));
// 類型創建和判斷
Object object = User.class.newInstance() ;
System.out.println("類型："+(object instanceof User));
System.out.println("類型："+(userClass3.isInstance(user1)));
}
輸出結果：
這里有個注意點：通過Class對象的newInstance()方法，即基於User類的無參構造器，首先要求User類具有無參構造方法。
API之Constructor構造器
Class對象讀取構造方法，可以分別獲得全部構造方法，不同修飾類型的構造方法，或者根據構造參數類型指定獲取：
public static void main(String[] args) throws Exception {
Class userClass = User.class ;
// 讀取公共構造方法
Constructor[] userConArr = userClass.getConstructors();
printCon(userConArr);
// 讀取指定私有構造方法
Constructor privateCon = userClass.getDeclaredConstructor(Integer.class);
System.out.println(privateCon);
// 讀取全部構造方法
userConArr = userClass.getDeclaredConstructors();
printCon(userConArr);
// 調用公共構造方法創建對象
Constructor pubCon = userClass.getConstructor(Integer.class,String.class);
Object pubUser = pubCon.newInstance(1,"hello") ;
// 調用私有構造方法創建對象
Constructor priCon = userClass.getDeclaredConstructor(Integer.class);
// 忽略private權限修飾符
priCon.setAccessible(Boolean.TRUE);
Object priUser = priCon.newInstance(2) ;
System.out.println(pubUser+"\n"+priUser);
}
public static void printCon (Constructor[] constructors){
for (Constructor constructor:constructors){
System.out.println(constructor);
}
}
這里需要注意的是，通過調用setAccessible(Boolean.TRUE)方法，可以基於私有構造方法創建對象，這里明顯違背了Java的基本設計原則，破壞代碼的安全性。
API之Field屬性
Field保證成員變量的屬性，修飾符，值管理等相關操作：
public static void main(String[] args) throws Exception {
Class userClass = User.class ;
// 獲取公共字段
Field[] pubArr = userClass.getFields() ;
printField(pubArr);
// 獲取全部字段
Field[] fieldArr = userClass.getDeclaredFields() ;
printField(fieldArr);
// 獲取指定字段
Field emailField = userClass.getField("email") ;
Field nameField = userClass.getDeclaredField("name") ;
printField(new Field[]{emailField,nameField});
// 創建對象並操作屬性
Object userObj = userClass.newInstance() ;
nameField.setAccessible(Boolean.TRUE);
nameField.set(userObj,"world");
emailField.set(userObj,"test@email.com");
System.out.println("userObj:"+userObj);
}
/**
* 打印成員變量信息
*/
public static void printField (Field[] fields){
for (Field field : fields){
System.out.println("聲明："+field);
UserAnno userAnno = field.getAnnotation(UserAnno.class) ;
System.out.println("注解："+userAnno.desc());
String fieldName = field.getName() ;
System.out.println("名稱："+fieldName);
Type type = field.getGenericType() ;
System.out.println("類型："+type);
}
}
注意這里獲取Type類型信息，在有些特定的業務場景下還是十分有用的。
API之Method方法
public static void main(String[] args) throws Exception {
Class userClass = User.class ;
// 獲取所有公共方法[包括父類和Object類方法]
Method[] pubMethods = userClass.getMethods() ;
printMethod(pubMethods);
// 獲取全部方法
Method[] allMethods = userClass.getDeclaredMethods() ;
printMethod(allMethods);
// 獲取指定方法
Method method = userClass.getMethod("parName",String.class) ;
printMethod(new Method[]{method});
// 調用方法
Object userObj = userClass.newInstance() ;
Method setId = userClass.getDeclaredMethod("setId", Integer.class);
setId.invoke(userObj,99) ;
Method setName = userClass.getDeclaredMethod("setName", String.class);
setName.invoke(userObj,"java") ;
Method sayHi = userClass.getDeclaredMethod("sayHi", String.class);
sayHi.setAccessible(Boolean.TRUE);
sayHi.invoke(userObj,"c++");
System.out.println(userObj);
}
/**
* 打印方法信息
*/
public static void printMethod (Method[] methods){
for (Method method : methods){
System.out.println("定義："+method);
System.out.println("命名："+method.getName());
UserAnno userAnno = method.getAnnotation(UserAnno.class) ;
if (userAnno != null){
System.out.println("注解："+userAnno.desc());
}
Type[] paramTypeArr = method.getParameterTypes();
for (int i=0 ; i< paramTypeArr.length; i++){
System.out.print("參數"+(i+1)+"類型："+paramTypeArr[i]+" ; ");
}
System.out.println("參數個數："+method.getParameterCount());
}
}
注意這里對方法的獲取遠遠不止類本身定義的，包括從父類繼承的，和Java基礎Object類中的。
三、源代碼地址
GitHub·地址
https://github.com/cicadasmile/java-base-parent
GitEE·地址
https://gitee.com/cicadasmile/java-base-parent
閱讀標簽
【Java基礎】【設計模式】【結構與算法】【Linux系統】【數據庫】
【分布式架構】【微服務】【大數據組件】【SpringBoot進階】【Spring&Boot基礎】