小編給大家分享一下Java中kotlin的協變與逆變是什么，希望大家閱讀完這篇文章后大所收獲，下面讓我們一起去探討吧！

云陽ssl適用于網站、小程序/APP、API接口等需要進行數據傳輸應用場景，ssl證書未來市場廣闊！成為創(chuàng)新互聯公司的ssl證書銷售渠道，可以享受市場價格4-6折優(yōu)惠！如果有意向歡迎電話聯系或者加微信：028-86922220（備注：SSL證書合作）期待與您的合作！

java基礎教程欄目今天介紹kotlin的協變與逆變。

前言

為了更好地理解 kotlin 和 Java 中的協變與逆變，先看一些基礎知識。

普通賦值

在 Java 中，常見的賦值語句如下：

A a = b;復制代碼

賦值語句必須滿足的條件是：左邊要么是右邊的父類，要么和右邊類型一樣。即 A 的類型要“大于”B 的類型，比如 Object o = new String("s"); 。為了方便起見，下文中稱作 A > B。

除了上述最常見的賦值語句，還有兩種其他的賦值語句：

函數參數的賦值

public void fun(A a) {}// 調用處賦值B b = new B();
fun(b);復制代碼

在調用 fun(b) 方法時，會將傳入的 B b 實參賦值給形參 A a，即 A a = b 的形式。同樣的，必須要滿足形參類型大于實參，即 A > B。

函數返回值的賦值

public A fun() {
    B b = new B();    return b;
} 
復制代碼

函數返回值類型接收實際返回類型的值，實際返回類型 B b 相當于賦值給了函數返回值類型 A a，即 B b 賦值給了 A a, 即 A a = b，那么必須滿足 A > B 的類型關系。

所以，無論哪種賦值，都必須滿足左邊類型 > 右邊類型，即 A > B。

Java 中的協變與逆變

有了前面的基礎知識，就可以方便地解釋協變與逆變了。

如果類 A > 類 B，經過一個變化 trans 后得到的 trans(A) 與 trans(B) 依舊滿足 trans(A) > trans(B)，那么稱為協變。

逆變則剛好相反，如果類 A > 類 B，經過一個變化 trans 后得到的 trans(A) 與 trans(B) 滿足 trans(B) > trans(A)，稱為逆變。

比如大家都知道 Java 的數組是協變的，假如 A > B，那么有 A[] > B[]，所以 B[] 可以賦值給 A[]。舉個例子：

Integer[] nums = new Integer[]{};
Object[] o = nums; // 可以賦值，因為數組的協變特性所以由 Object > Integer 得到 Object[] > Integer[]復制代碼

但是 Java 的泛型則不滿足協變，如下：

List<Integer> l = new ArrayList<>();
List<Object> o = l;// 這里會報錯，不能編譯復制代碼

上述代碼報錯，就是因為，雖然 Object > Integer，但是由于泛型不滿足協變，所以 List<Object> > List<Integer> 是不滿足的，既然不滿足左邊大于右邊這個條件，從前言中我們知道，自然就不能將 List<Integer> 賦值給 List<Object>。一般稱 Java 泛型不支持型變。

Java 中泛型如何實現協變與逆變

從前面我們知道，在 Java 中泛型是不支持型變的，但是這會產生一個讓人很奇怪的疑惑，也是很多講泛型的文章中提到的：

如果 B 是 A 的子類，那么 List<B> 就應該是 List<A> 的子類呀！這是一個非常自然而然的想法！

但是很抱歉，由于種種原因，Java 并不支持。但是，Java 并不是完全抹殺了泛型的型變特性，Java 提供了 <? extends T> 和 <? super T> 使泛型擁有協變和逆變的特性。

<? extends T> 與 <? super T>

<? extends T> 稱為上界通配符，<? super T> 稱為下界通配符。使用上界通配符可以使泛型協變，而使用下界通配符可以使泛型逆變。

比如之前舉的例子

List<Integer> l = new ArrayList<>();
List<Object> o = l;// 這里會報錯，不能編譯復制代碼

如果使用上界通配符，

List<Integer> l = new ArrayList<>();
List<? extends Object> o = l;// 可以通過編譯復制代碼

這樣，List<? extends Object> 的類型就大于 List<Integer> 的類型了，也就實現了協變。這也就是所謂的“子類的泛型是泛型的子類”。

同樣，下界通配符 <? super T> 可以實現逆變，如：

public List<? super Integer> fun(){
    List<Object> l = new ArrayList<>();    return l;
}復制代碼

上述代碼怎么就實現逆變了呢？首先，Object > Integer；另外，從前言我們知道，函數返回值類型必須大于實際返回值類型，在這里就是 List<? super Integer> > List<Object>，和 Object > Integer 剛好相反。也就是說，經過泛型變化后，Object 和 Integer 的類型關系翻轉了，這就是逆變，而實現逆變的就是下界通配符 <? super T>。

從上面可以看出，<? extends T> 中的上界是 T，也就是說 <? extends T> 所泛指的類型都是 T 的子類或 T 本身，所以 T 大于 <? extends T> 。<? super T> 中的下界是 T，也就是說 <? super T> 所泛指的類型都是 T 的父類或 T 本身，所以 <? super T>  大于 T。

雖然 Java 使用通配符解決了泛型的協變與逆變的問題，但是由于很多講到泛型的文章都晦澀難懂，曾經讓我一度感慨這 tm 到底是什么玩意？直到我在 stackoverflow 上發(fā)現了通俗易懂的解釋(是的，前文大部分內容都來自于 stackoverflow 中大神的解釋)，才終于了然。其實只要抓住賦值語句左邊類型必須大于右邊類型這個關鍵點一切就都很好懂了。

PECS

PECS 準則即 Producer Extends Consumer Super，生產者使用上界通配符，消費者使用下界通配符。直接看這句話可能會讓人很疑惑，所以我們追本溯源來看看為什么會有這句話。

首先，我們寫一個簡單的泛型類：

public class Container<T> {    private T item;    public void set(T t) { 
        item = t;
    }    public T get() {        return item;
    }
}復制代碼

然后寫出如下代碼：

Container<Object> c = new Container<String>(); // (1)編譯報錯Container<? extends Object> c = new Container<String>(); // (2)編譯通過c.set("sss"); // (3)編譯報錯Object o = c.get();// (4)編譯通過復制代碼

代碼 (1)，Container<Object> c = new Container<String>(); 編譯報錯，因為泛型是不型變的，所以 Container<String> 并不是 Container<Object> 的子類型，所以無法賦值。

代碼 (2)，加了上界通配符以后，支持泛型協變，Container<String> 就成了 Container<? extends Object> 的子類型，所以編譯通過，可以賦值。

既然代碼 (2) 通過編譯，那代碼 (3) 為什么會報錯呢？因為代碼 (3) 嘗試把 String 類型賦值給 <? extends Object> 類型。顯然，編譯器只知道 <? extends Object>  是 Obejct 的某一個子類型，但是具體是哪一個并不知道，也許并不是 String 類型，所以不能直接將 String 類型賦值給它。

從上面可以看出，對于使用了 <? extends T> 的類型，是不能寫入元素的，不然就會像代碼 (3) 處一樣編譯報錯。

但是可以讀取元素，比如代碼 (4) 。并且該類型只能讀取元素，這就是所謂的“生產者”，即只能從中讀取元素的就是生產者，生產者就使用 <? extends T> 通配符。

消費者同理，代碼如下：

Container<String> c = new Container<Object>(); // (1)編譯報錯Container<? super String> c = new Container<Object>(); // (2)編譯通過
 c.set("sss");// (3) 編譯通過
 String s = c.get();// (4) 編譯報錯復制代碼

代碼 (1) 編譯報錯，因為泛型不支持逆變。而且就算不懂泛型，這個代碼的形式一眼看起來也是錯的。

代碼 (2) 編譯通過，因為加了 <? super T> 通配符后，泛型逆變。

代碼 (3) 編譯通過，它把 String 類型賦值給 <? super String>，<? super String> 泛指 String 的父類或 String，所以這是可以通過編譯的。

代碼 (4) 編譯報錯，因為它嘗試把 <? super String> 賦值給 String，而 <? super String> 大于 String，所以不能賦值。事實上，編譯器完全不知道該用什么類型去接受 c.get() 的返回值，因為在編譯器眼里 <? super String> 是一個泛指的類型，所有 String 的父類和 String 本身都有可能。

同樣從上面代碼可以看出，對于使用了 <? super T> 的類型，是不能讀取元素的，不然就會像代碼 (4) 處一樣編譯報錯。但是可以寫入元素，比如代碼 (3)。該類型只能寫入元素，這就是所謂的“消費者”，即只能寫入元素的就是消費者，消費者就使用 <? super T> 通配符。

綜上，這就是 PECS 原則。

kotlin 中的協變與逆變

kotlin 拋棄了 Java 中的通配符，轉而使用了聲明處型變與類型投影。

聲明處型變

首先讓我們回頭看看 Container 的定義：

public class Container<T> {    private T item;    public void set(T t) { 
        item = t;
    }    public T get() {        return item;
    }
}復制代碼

在某些情況下，我們只會使用 Container<? extends T> 或者 Container<? super T> ，意味著我們只使用 Container 作為生產者或者 Container 作為消費者。

既然如此，那我們?yōu)槭裁匆诙x Container 這個類的時候要把 get 和 set 都定義好呢？試想一下，如果一個類只有消費者的作用，那定義 get 方法完全是多余的。

反過來說，如果一個泛型類只有生產者方法，比如下面這個例子（來自 kotlin 官方文檔）:

// Javainterface Source<T> {
  T nextT(); // 只有生產者方法}// Javavoid demo(Source<String> strs) {
  Source<Object> objects = strs; // ?。?！在 Java 中不允許，要使用上界通配符 <? extends Object>
  // ……}復制代碼

在 Source<Object> 類型的變量中存儲 Source<String> 實例的引用是極為安全的——因為沒有消費者-方法可以調用。然而 Java 依然不讓我們直接賦值，需要使用上界通配符。

但是這是毫無意義的，使用通配符只是把類型變得更復雜，并沒有帶來額外的價值，因為能調用的方法還是只有生產者方法。但 Java 編譯器只認死理。

所以，如果我們能在使用之前確定一個類是生產者還是消費者，那在定義類的時候直接聲明它的角色豈不美哉？

這就是 kotlin 的聲明處型變，直接在類聲明的時候，定義它的型變行為。

比如：

class Container<out T> { // (1)
    private  var item: T? = null 
        
    fun get(): T? = item
}

val c: Container<Any> = Container<String>()// （2）編譯通過，因為 T 是一個 out-參數復制代碼

(1) 處直接使用 <out T> 指定 T 類型只能出現在生產者的位置上。雖然多了一些限制，但是，在 kotlin 編譯器在知道了 T 的角色以后，就可以像 (2) 處一樣將 Container<String> 直接賦值給 Container<Any>，好像泛型直接可以協變了一樣，而不需要再使用 Java 當中的通配符 <? extends String>。

同樣的，對于消費者來說，

class Container<in T> { // (1) 
    private  var item: T? = null 
     fun set(t: T) {
        item = t
    }
}val c: Container<String> = Container<Any>() // (2) 編譯通過,因為 T 是一個 in-參數復制代碼

代碼 (1) 處使用 <in T> 指定 T 類型只能出現在消費者的位置上。代碼 (2) 可以編譯通過， Any > String，但是 Container<String> 可以被 Container<Any> 賦值，意味著 Container<String> 大于 Container<Any> ，即它看上去就像 T 直接實現了泛型逆變，而不需要借助 <? super String> 通配符來實現逆變。如果是 Java 代碼，則需要寫成 Container<? super String> c = new Container<Object>(); 。

這就是聲明處型變，在類聲明的時候使用 out 和 in 關鍵字，在使用時可以直接寫出泛型型變的代碼。

而 Java 在使用時必須借助通配符才能實現泛型型變，這是使用處型變。

類型投影

有時一個類既可以作生產者又可以作消費者，這種情況下，我們不能直接在 T 前面加 in 或者 out 關鍵字。比如：

class Container<T> {    private  var item: T? = null
    
    fun set(t: T？) {
        item = t
    }    fun get(): T? = item
}復制代碼

考慮這個函數：

fun copy(from: Container<Any>, to: Container<Any>) {
    to.set(from.get())
}復制代碼

當我們實際使用該函數時：

val from = Container<Int>()val to = Container<Any>()
copy(from, to) // 報錯，from 是 Container<Int> 類型，而 to 是 Container<Any> 類型復制代碼

這樣使用的話，編譯器報錯，因為我們把兩個不一樣的類型做了賦值。用 kotlin 官方文檔的話說，copy 函數在”干壞事“， 它嘗試寫一個 Any 類型的值給 from， 而我們用 Int 類型來接收這個值，如果編譯器不報錯，那么運行時將會拋出一個 ClassCastException 異常。

所以應該怎么辦？直接防止 from 被寫入就可以了！

將 copy 函數改為如下所示：

fun copy(from: Container<out Any>, to: Container<Any>) { // 給 from 的類型加了 out
    to.set(from.get())
}val from = Container<Int>()val to = Container<Any>()
copy(from, to) // 不會再報錯了復制代碼

這就是類型投影：from 是一個類受限制的（投影的）Container 類，我們只能把它當作生產者來使用，它只能調用 get() 方法。

同理，如果 from 的泛型是用 in 來修飾的話，則 from 只能被當作消費者使用，它只能調用 set() 方法，上述代碼就會報錯：

fun copy(from: Container<in Any>, to: Container<Any>) { // 給 from 的類型加了 in
    to.set(from.get())
}val from = Container<Int>()val to = Container<Any>()
copy(from, to) //  報錯復制代碼

其實從上面可以看到，類型投影和 Java 的通配符很相似，也是一種使用時型變。

為什么要這么設計？

為什么 Java 的數組是默認型變的，而泛型默認不型變呢？其實 kolin 的泛型默認也是不型變的，只是使用 out 和 in 關鍵字讓它看起來像泛型型變。

為什么這么設計呢？為什么不默認泛型可型變呢？

在 stackoverflow 上找到了答案，參考：stackoverflow.com/questions/1…

Java 和 C# 早期都是沒有泛型特性的。

但是為了支持程序的多態(tài)性，于是將數組設計成了協變的。因為數組的很多方法應該可以適用于所有類型元素的數組。

比如下面兩個方法：

boolean equalArrays (Object[] a1, Object[] a2);void shuffleArray(Object[] a);復制代碼

第一個是比較數組是否相等；第二個是打亂數組順序。

語言的設計者們希望這些方法對于任何類型元素的數組都可以調用，比如我可以調用 shuffleArray(String[] s) 來把字符串數組的順序打亂。

出于這樣的考慮，在 Java 和 C# 中，數組設計成了協變的。

然而，對于泛型來說，卻有以下問題：

// Illegal code - because otherwise life would be BadList<Dog> dogs = new List<Dog>();
List<Animal> animals = dogs; // Awooga awoogaanimals.add(new Cat());// (1)Dog dog = dogs.get(0); //(2) This should be safe, right?復制代碼

如果上述代碼可以通過編譯，即 List<Dog> 可以賦值給 List<Animal>，List 是協變的。接下來往 List<Dog> 中 add 一個 Cat()，如代碼 (1) 處。這樣就有可能造成代碼 (2) 處的接收者 Dog dog 和 dogs.get(0) 的類型不匹配的問題。會引發(fā)運行時的異常。所以 Java 在編譯期就要阻止這種行為，把泛型設計為默認不型變的。

總結

1、Java 泛型默認不型變，所以 List<String> 不是 List<Object> 的子類。如果要實現泛型型變，則需要 <? extends T> 與 <? super T> 通配符，這是一種使用處型變的方法。使用 <? extends T> 通配符意味著該類是生產者，只能調用 get(): T 之類的方法。而使用 <? super T> 通配符意味著該類是消費者，只能調用 set(T t)、add(T t) 之類的方法。

2、Kotlin 泛型其實默認也是不型變的，只不過使用 out 和 in 關鍵字在類聲明處型變，可以達到在使用處看起來像直接型變的效果。但是這樣會限制類在聲明時只能要么作為生產者，要么作為消費者。

使用類型投影可以避免類在聲明時被限制，但是在使用時要使用 out 和 in 關鍵字指明這個時刻類所充當的角色是消費者還是生產者。類型投影也是一種使用處型變的方法。

看完了這篇文章，相信你對Java中kotlin的協變與逆變是什么有了一定的了解，想了解更多相關知識，歡迎關注創(chuàng)新互聯-成都網站建設公司行業(yè)資訊頻道，感謝各位的閱讀！

當前名稱：Java中kotlin的協變與逆變是什么-創(chuàng)新互聯
轉載來于：http://aaarwkj.com/article40/ddodeo.html

成都網站建設公司_創(chuàng)新互聯，為您提供定制網站、外貿建站、搜索引擎優(yōu)化、App開發(fā)、電子商務、網站設計

廣告

聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯