Java泛型可行與不可行的原理示例解析

更新時(shí)間：2023年05月31日 14:39:40 作者：Mzoro

這篇文章主要為大家介紹了Java泛型可行與不可行的原理示例解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加

泛型基礎(chǔ)理解

一般情況，一個(gè)類的屬性，或者一個(gè)方法的參數(shù) / 返回值都需要在編寫代碼時(shí)聲明基本類型或者自定義類型，但有時(shí)候無法在編寫代碼時(shí)使用現(xiàn)有的類來表達(dá)參數(shù)類型或者返回值類型，這時(shí)候就需有一種方式可以表達(dá)下面的意思：這里需要一個(gè)類，它滿足這些要求就可以了，具體是什么類可以在使用這個(gè)類或方法時(shí)指定。Java 中這種方式就是泛型。但是 java 泛型在使用上有很多限制，使用時(shí)要注意，同時(shí)注意泛型主義上的理解，Java 中泛型的聲明使用更多

作用

一定程序上繼承與接口就可以完成上面的功能，但泛型有很多額外的作用

泛型可以更安全
使用泛型就是告訴編譯器想使用什么類型，在使用泛型時(shí)編譯器會對代碼進(jìn)行類型檢查，讓錯(cuò)誤暴露在編譯期，而不是運(yùn)行期，更安全

可以快速創(chuàng)建復(fù)雜的類型

因?yàn)樵诰帉憰r(shí)沒有指定具體類型，所以在使用時(shí)就可以更隨意的指定類型，這個(gè)功能可以完成類似 js 中對象的功能，對象的屬性規(guī)定好，具體是什么類型你隨便，但是沒能像 js 那樣隨意添加屬性

public class TupleTest<T, R> {
    public final T t;
    public final R r;
    public TupleTest(T t, R r) {
        this.t = t;
        this.r = r;
    }
    public static <A, B> TupleTest<A, B> make(A a, B b) {
        return new TupleTest<>(a, b);
    }
    /**
     * 如果返回值聲明里聲明了泛型，那么在方法返回值 new 時(shí)就要有尖括號，不然會警告
     * jdk1.5中返回值聲明時(shí)的泛型去掉，也會有編譯警告
     *
     * @return tupleTest
     */
    public TupleTest<String, String> make() {
        return new TupleTest<>("a", "b");
    }
     public R getR() {
        return r;
    }
}

可以自動完成類型的轉(zhuǎn)換

在泛型出現(xiàn)之前，如果一個(gè)方法不能確定方法的返回值類型，或者根據(jù)入?yún)⒖梢源_定多種類型返回值類型，那么這個(gè)方法就只能返回 Object ，有了泛型之后，在方法返回正確的值后，會自動轉(zhuǎn)為具體的類型，而這在代碼上沒有額外的代碼，而且這種轉(zhuǎn)換很安全

上面例子編譯之后再反編譯回來 make 方法是這樣的

 public com.zoro.thinkinginjava.four.TupleTest<String, String> make() {
    return new com.zoro.thinkinginjava.four.TupleTest((T)"a", (R)"b");
  }

再看一個(gè)調(diào)用時(shí)的代碼

public class TupleMain {
    public static void main(String[] args) {
        TupleTest<Apple, Orange> tuple = new TupleTest<>(new Apple(), new Orange());
        Orange orange = tuple.getR();
    }
}

反編譯之后

public class TupleMain {
  public static void main(String[] args) {
    TupleTest<Apple, Orange> tuple = new TupleTest(new Apple(), new Orange());
    Orange orange = (Orange)tuple.getR();
  }
}

可以看到自動對參數(shù)進(jìn)行了轉(zhuǎn)型，所以編譯器不會產(chǎn)生轉(zhuǎn)型警告

還有一些更高級的用法，比如 泛型自限定

困難之處

書寫泛型代碼的主要困難是因?yàn)榉盒驮谶\(yùn)行時(shí)被擦除，所以在運(yùn)行期沒有泛型類的具體信息，這意味著泛型參數(shù)看上去就借一個(gè) Object 類，什么都干不了，需要注意以下方法

同樣的類型，不同的泛型參數(shù)在編譯期代表著不同類型，在運(yùn)行期就沒有差別了

public class EraseMain {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
//        list1 = list2; // 編譯期是不同的
        System.out.println(list1.getClass().getName());
        System.out.println(list2.getClass().getName());
        // 運(yùn)行期類型是相同的
        System.out.println(list1.getClass() == list2.getClass());
    }
}

不能使用 new 來創(chuàng)建泛型類型的具體對象，最好的方案是使用 Class.newInstance () 或者使用工場模式

public T getNewInstance() {
        // return new T();
        // Error:(12, 20) java: 意外的類型
        //  需要: 類
        //  找到:    類型參數(shù)T
        try {
            return t.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

不能使用 instanceof 操作符了，但可以用 Class.isInstance (Object) 方法

public class EraseEntity<T> {
    Class<T> tClass;
    public EraseEntity(Class<T> tClass) {
        this.tClass = tClass;
    }
    public boolean instanceOf(Object t) {
//        return t instanceof T; // 這樣就不可以了
        return tClass.isInstance(t); // 這樣是可以的
    }
}

不能 new 一個(gè)泛型數(shù)組，而且要產(chǎn)生泛型數(shù)組非常麻煩，可以使用 Array.newInstance (Class<?>,int)

    public T[] createArray(){
        return (T[]) Array.newInstance(t,5);
    }

但是這樣也會有警告，需要壓制

除非設(shè)定邊界，否則不能調(diào)用任何自定義的方法

基本類型不能作為泛型參數(shù)，但是其包裝類型可以，并可以自動包裝

//        List<int> list2 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();

一個(gè)類不能實(shí)現(xiàn)同一個(gè)泛型接口的兩種變體，但去掉泛型實(shí)現(xiàn)可以；

public class ImplTest extends AbstractA implements InterfaceA<Integer> {
//public class ImplTest extends AbstractA implements InterfaceA<String> {
// ImplTest類實(shí)現(xiàn)InterfaceA接口時(shí)聲明的泛型參數(shù)是String,AbstractA實(shí)現(xiàn)InterfaceA時(shí)聲明的泛型參數(shù)是 Integer,這時(shí)就不可以了，
// 如果可以會導(dǎo)致類型沖突,比如 get方法，在AbstractA中返回值是Integer,但是在ImplTest中就變成了String，無論重載或重寫都不能解決這個(gè)問題
}
interface InterfaceA<T> {
    T get(T t);
}
abstract class AbstractA implements InterfaceA<Integer> {
    public Integer get(Integer integer) {
        return 0;
    }
}

不能通過不同的泛型參數(shù)進(jìn)行方法重載，但是可以使用 <R extends List<?>> 給泛型參數(shù)添加邊界重載方法

public class OverLoadTest {
    public <T> void test(T t) { }
    // 因?yàn)門與R沒有設(shè)置邊界在運(yùn)行時(shí) T與R 都是類似Object，所以不能通過方法簽名區(qū)分這兩個(gè)方法
//    public <R> void test(R r) { }
    // 這樣是可以的 因?yàn)镽一定會是一個(gè)List的子類，List與Object（T）是有區(qū)別的，就可以通過方法簽名區(qū)分了
    public <R extends List<?>> void test(R r) {    }
}

泛型邊界

可以使用 extends 限定泛型類型的邊界，可以是多個(gè)（& 連接），類寫在前面，限定邊界之后在泛型方法或者類的內(nèi)部就可以使用邊界類上的方法了

public class WildCardTest<T extends List<String> & Iterable<String> & InterfaceA<?>> {
    public void test(T t) {
        t.add("");  // List接口的方法
        t.iterator(); // Iterable接口的方法
        t.testMethod(); // InterfaceA方法
    }
}
interface InterfaceA<T>{
    //    void add(T t); // List接口也有同樣方法簽名的方法，所以在 同時(shí)將 List與InterfaceA設(shè)置為上邊界時(shí)List與InterfaceA的泛型參數(shù)要兼容，否則也會出錯(cuò)
    void testMethod();
}

通配符

通配符在泛型中的應(yīng)用是為了解決下面的問題：有一個(gè)容器的泛型是基類的變量，想要將一個(gè)泛型是子類的容器賦值給這個(gè)變量，編譯器是不允許的；因?yàn)檫\(yùn)行時(shí)會將泛型擦除，一旦將一個(gè)泛型是子類的容器賦值給泛型是基類的容器變量，在運(yùn)行時(shí)就可以將一個(gè)這個(gè)基類的其他子類對象放入這個(gè)窗口，造成在取出對象時(shí)的類型不安全，所以編譯期不允許這樣賦值；

public class WildCardTest<T extends List<String> & Iterable<String> & InterfaceA<?>> {
    public static void main(String[] args) {
        List<InterfaceA<String>> list ;
        List<Impl> impls = new ArrayList<>();
//        list = impls;
        // 將 impls賦值給 list是不可以的，原因：
        // 1. 編譯期 List<InterfaceA<String>> 與 List<Impl>是不同的且不能向上轉(zhuǎn)型
        // 2. 一旦允許這樣賦值，那么之后 的操作會出現(xiàn)類型問題，比如此例，將一個(gè)ArrayList<Impl> 賦值給 List<InterfaceA>變量list，
        // 那么之后可以向list 中add 一個(gè) Impl2對象，Impl2與Impl不兼容
    }
}
interface InterfaceA<T>{}
class Impl implements InterfaceA<String> {}
class Impl2 implements InterfaceA<String> {}

容器的這一特點(diǎn)與數(shù)組不同，子類數(shù)組對象可以賦值給基類數(shù)組變量（類似向上轉(zhuǎn)型），但是在運(yùn)行期 jvm 可以知道數(shù)組元素中的對象類型是哪個(gè)具體子類，所以如果將數(shù)組中元素賦值時(shí)，如果不是原數(shù)組中的類型，會報(bào)錯(cuò)（ArrayStoreException）

public class WildCardTest2 {
    public static void main(String[] args) {
        InterfaceA<?>[] arr1 = new Impl[3];
        arr1[0] = new Impl();
        //會報(bào)錯(cuò)
        //arr1[2] = new Impl2();
        // 兼容的類型可以
        InterfaceA<?>[] arr2 = new InterfaceA[4];
        arr2[0] = new Impl();
        arr2[0] = new Impl2();
    }
}

為了保證類型安全，又可以將子類泛型容器賦值給基類泛型變量，可以使用通配符（單一邊界，extends 后面只能有一個(gè)類型）

通配符的困難之處

當(dāng)一個(gè)類在聲明時(shí)使用了 <? extends Fruit> 這種泛型，而這個(gè)類的寫法如同下面這樣

class TestClass<T>{
	public void test(T t){
		// somecode
	}
    public void test2(Object o){
        // somecode
    }
}

在使用時(shí)

TestClass<? extends Fruit> f = new TestClass<Apple>;

這樣寫會出現(xiàn)的問題是不能調(diào)用 test(T) 方法了，因?yàn)?test 需要的是一個(gè)具體的 Fruit 的子類，例子中應(yīng)該是 Applie, 但 ? extends Fruit 代表的不僅僅是 Apple 這一種子類，也可能是 orange 。如果調(diào)用時(shí)真的用 orange 類型實(shí)例做為能數(shù)，類型就不安全，所以 test(T) 方法不能用了；但是 test2(Object) 還可以用

逆變

逆變指的是 < ? super Apple> 這種寫法，這種寫法的特性與 <? extends Apple> 的寫法的特性是相反的。上面的例子，泛型入?yún)⒎椒ú荒苡昧耍孀兊奶匦允侨雲(yún)⒖梢允侨魏?Apple 的子類，注意是子類，不是基類，因?yàn)?Apple 的基類有多種，如果編譯器允許傳入基類，就會存在風(fēng)險(xiǎn)，但是傳入子類就不會有風(fēng)險(xiǎn)，因?yàn)樽宇惪梢赞D(zhuǎn)型為 Apple 類，Apple 類可以算是 Apple 的基類；

public class WildcardTest4 {
    public static void main(String[] args) {
        List<? super Apple> appleList = new ArrayList<Fruit>();
        List<? super Apple> appleList2 = new ArrayList<Apple>();
        List<? super Apple> appleList3 = new ArrayList<>();
        // 前三種情況都可以，但是這種不可以
//    List<? super Apple> appleList4 = new ArrayList<BigApple>();
        // 不可以
        //appleList3.add(new Orange());
        appleList3.add(new Apple());
        appleList3.add(new BigApple());
        // 雖然字面上是 任何 Apple 的父類，但是Apple父類很多，不能確定類型，所以實(shí)際上任何Apple 的父類都不行
        //appleList3.add(new Fruit());
        // 只能Object 接
        Object a = appleList3.get(1);
    }
}
class Fruit {}
class Orange extends Fruit {}
class Apple extends Fruit {}
class BigApple extends Apple implements Runnable {
    @Override
    public void run() {
    }
}
class SmallApple extends Apple {}

逆變的困難之處在于方法的返回值，它的返回值只能用 Object 類型的變量接受

無界通配符

兩個(gè)功能

這里想用泛型代碼來編寫，這里并不是要用原生的類型，但是當(dāng)前情況下，泛型參數(shù)可以持有任何類型
當(dāng)有個(gè)地方需要多個(gè)泛型參數(shù)，但你只能確定一部分時(shí)可以使用無界通配符？ 例：Map<String, ?>
當(dāng)一個(gè)地方要求泛型，如果你沒有給出泛型，會有警告，但使用無界通配符會消除警告

無界通配符與原生類型是不一樣的，以 List 和 List<?> 為例，List 代表持有任何 Object 類型的 List,List<?> 代表具有某種特定類型的的非原生 List, 但目前不確定是什么類型；

下面例子顯示這種區(qū)別

public class WildcardTest5 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Apple());// 有警告，但是不會編譯報(bào)錯(cuò)
        Object o = list.get(0);
        List<?> list1 = new ArrayList<>();
//        list1.add(new Apple());// 不可這樣寫，編譯報(bào)錯(cuò)
    }
}