一、泛型的概念
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 = https://www.cnblogs.com/cicada-smile/archive/2021/06/23/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,"[email protected]");
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基礎】
【資料分析】【技術導圖】【 職場】
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/288303.html
標籤：其他
上一篇：溫故而知新--day5