Java泛型背後是什麼？

  • 2021 年 10 月 21 日
  • 筆記

文Java中泛型的應用，讓大家更好地理解泛型，以及常說的泛型類型擦除是什麼概念，舉一個簡單的例子，如下: 

這裡可以看出來在代碼編寫階段就已經報錯了，不能往string類型的集合中添加int類型的數據。

那可不可以往List集合中添加多個類型的數據呢，答案是可以的，其實我們可以把list集合當成普通的類也是沒問題的，那麼就有下面的代碼:

從這裡可以看出來，不定義泛型也是可以往集合中添加數據的，所以說泛型只是一種類型的規範，在代碼編寫階段起一種限制。

下面我們通過例子來介紹泛型背後數據是什麼類型

public class BaseBean<T> {
    T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

上面定義了一個泛型的類，然後我們通過反射獲取屬性和getValue方法返回的數據類型:

        BaseBean<String> stringBaseBean = new BaseBean<>();
        stringBaseBean.setValue("China");
        try {
            // 獲取屬性上的泛型類型
            Field value = stringBaseBean.getClass().getDeclaredField("value");
            Class<?> type = value.getType();
            String name = type.getName();
            System.out.println(name);

            // 獲取方法上的泛型類型
            Method getValue = stringBaseBean.getClass().getDeclaredMethod("getValue");
            Object invoke = getValue.invoke(stringBaseBean);
            String methodName = invoke.getClass().getName();
            System.out.println(methodName);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

從日誌上看到通過反射獲取到的屬性是Object類型的，在方法中返回的是string類型，因此咋們可以思考在getValue方法裏面實際是做了個強轉的動作，將object類型的value強轉成string類型。

是的，沒錯，因為泛型只是為了約束我們規範代碼，而對於編譯完之後的class交給虛擬機後，對於虛擬機它是沒有泛型的說法的，所有的泛型在它看來都是object類型，因此泛型擦除是對於虛擬機而言的。

下面我們再來看一種泛型結構:

public class BaseBean<T extends String> {
    T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public void add(Class<? super Common> clazz) {
    }

}

這裡我將泛型加了個關鍵字extends，對於泛型寫得多的夥伴們來說，extends是約束了泛型是向下繼承的，最後我們通過反射獲取value的類型是String類型的，因此這裡也不難看出，加extends關鍵字其實最終目的是約束泛型是屬於哪一類的。所以我們在編寫代碼的時候如果沒有向下兼容類型，會警告錯誤的：

大家有沒有想過為啥要用泛型呢，既然說了泛型其實對於jvm來說都是Object類型的，那咱們直接將類型定義成Object不就是的了，這種做法是可以，但是在拿到Object類型值之後，自己還得強轉，因此泛型減少了代碼的強轉工作，而將這些工作交給了虛擬機。

比如下面我們沒有定義泛型的例子:

public class BaseBean {
    Object value;

    public Object geObjectValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

勢必在getValue的時候代碼有個強轉的過程，因此在能用泛型的時候，盡量用泛型來寫，而且我認為一個好的架構師，業務的抽取是離不開泛型的定義。

常見的泛型主要有作用在普通類上面，作用在抽象類、接口、靜態或非靜態方法上。

類上面的泛型

比如實際項目中，我們經常會遇到服務端返回的接口中都有errMsg、status等公共返回信息，而變動的數據結構是data信息，因此我們可以抽取公共的BaseBean：

public class BaseBean<T> {
    public String errMsg;
    public T data;
    public int status;
}

抽象類或接口上的泛型

//抽象類泛型
public abstract class BaseAdapter<T> {
    List<T> DATAS;
}
//接口泛型
public interface Factory<T> {
    T create();
}
//方法泛型
public static <T> T getData() {
    return null;
}

多元泛型

public interface Base<K, V> {
    void setKey(K k);

    V getValue();
}

泛型二級抽象類或接口

public interface BaseCommon<K extends Common1, V> extends Base<K, V> {
}
//或抽象類
public abstract class BaseCommon<K extends Common1, V> implements Base<K, V> {
}

抽象裏面包含抽象

public interface Base<K, V> {
   //    void setKey(K k);
//
//    V getValue();
   void addNode(Map<K, V> map);

   Map<K, V> getNode(int index);
}

public abstract class BaseCommon<K, V> implements Base<K, V> {
   //多重泛型
   LinkedList<Map<K, V>> DATAS = new LinkedList<>();

   @Override
   public void addNode(Map<K, V> map) {
       DATAS.addLast(map);
   }

   @Override
   public Map<K, V> getNode(int index) {
       return DATAS.get(index);
   }

}

<?>通配符

<?>通配符和<T>區別是<?>在你不知道泛型類型的時候，可以用<?>通配符來定義，下面通過一個例子來看看<?>的用處:

public class BaseBean<T> {
    T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public static void main(String[] args) {
        BaseBean<Common> commonBaseBean = new BaseBean<>();
        BaseBean<Common1> common1BaseBean = commonBaseBean;
        
    }
}

class Common {
}

//用來定義泛型的
class Common1 extends Common {
}

在定義的時候將Common的泛型指向Common1的泛型，可以看到直接提示有問題，這裡可以想，雖然Common1是繼承自Common的，但是並不代表BaseBean之間是等量的，在開篇也講過，如果泛型傳入的是什麼類型，那麼在BaseBean中的getValue返回的類型就是什麼，因此可以想兩個不同的泛型類肯定是不等價的，但是如果我這裡寫呢:

public static void main(String[] args) {
    BaseBean<Common> commonBaseBean = new BaseBean<>();
    //通配符定義就沒有問題
    BaseBean<?> common1BaseBean = commonBaseBean;
    try {
        //通過反射猜測setValue的參數是Object類型的
        Method setValue = common1BaseBean.getClass().getDeclaredMethod("setValue", Object.class);
        setValue.invoke(common1BaseBean, "123");
        Object value = common1BaseBean.getValue();
        System.out.println("result:" + value);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}

在上面如果定義的泛型是通配符是可以等價的，因為此時的setValue的參數是Object類型，所以能直接將上面定義的泛型賦給通配符的BaseBean。

通配符不能定義在類上面、接口或方法上，只能作用在方法的參數上

其他的幾種情況自己去嘗試，正確的使用通配符:

public void setClass(Class<?> class){
    //todo
}

<T extends >、<T super >、<? extends >、<? super >
<T extends **>表示上限泛型、<T super **>表示下限泛型

為了演示這兩個通配符的作用，增加了一個類:

//新增加的一個BaseCommon
public class Common extends BaseCommon{
}

第二個定義的泛型是不合法的，因為BaseCommon是Common的父類，超出了Common的類型範圍。

<T super >不能作用在類、接口、方法上，只能通過方法傳參來定義泛型

在BaseBean裏面定義了個方法:

public void add(Class<? super Common> clazz) {
}

可以看到當傳進去的是Common1.class的時候是不合法的，因為在add方法中需要傳入Common父類的位元組碼對象，而Common1是繼承自Common，所以直接不合法。

在實際開發中其實知道什麼時候定義什麼類型的泛型就ok，在mvp實際案例中泛型用得比較廣泛，大家可以根據實際項目來找找泛型的感覺，只是面試的時候需要理解類型擦除是針對誰而言的。

類型擦除

其實在開篇的時候已經通過例子說明了，通過反射繞開泛型的定義，也說明了類中定義的泛型最終是以Object被jvm執行。所有的泛型在jvm中執行的時候，都是以Object對象存在的，加泛型只是為了一種代碼的規範，避免了開發過程中再次強轉。

泛型信息只存在於代碼編譯階段，在進入 JVM 之前，與泛型相關的信息會被擦除掉，專業術語叫做類型擦除。

 

 

 

 

 

原文參考公眾號《Java知音》

VirMach 便宜 VPS

QNews

QNews