欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Kotlin與Java 泛型缺陷和應(yīng)用場景詳解

 更新時間：2022年12月21日 15:01:51   作者：程序員DHL  
這篇文章主要為大家介紹了Kotlin與Java 泛型缺陷和應(yīng)用場景詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪

引言

全文分為 視頻版 和 文字版

  • 文字版： 文字側(cè)重細(xì)節(jié)和深度，有些知識點，視頻不好表達(dá)，文字描述的更加準(zhǔn)確
  • 視頻版： 視頻會更加的直觀，看完文字版，在看視頻，知識點會更加清楚

視頻版 bilibili 地址:https://b23.tv/AdLtUGf

泛型對于每個開發(fā)者而言并不陌生，平時在項目中會經(jīng)常見到，但是有很多小伙伴們，每次見到通配符 ? extends 、 ? super 、 out 、 in 都傻傻分不清楚它們的區(qū)別，以及在什么情況下使用。

通過這篇文章將會學(xué)習(xí)的到以下內(nèi)容。

  • 為什么要有泛型
  • Kotlin 和 Java 的協(xié)變
  • Kotlin 和 Java 的逆變
  • 通配符 ? extends 、 ? super 、 out 、 in 的區(qū)別和應(yīng)用場景
  • Kotlin 和 Java 數(shù)組協(xié)變的不同之處
  • 數(shù)組協(xié)變的缺陷
  • 協(xié)變和逆變的應(yīng)用場景

為什么要有泛型

在 Java 和 Kotlin 中我們常用集合（ List 、 Set 、 Map 等等）來存儲數(shù)據(jù)，而在集合中可能存儲各種類型的數(shù)據(jù)，現(xiàn)在我們有四種數(shù)據(jù)類型 Int 、 Float 、 Double 、 Number，假設(shè)沒有泛型，我們需要創(chuàng)建四個集合類來存儲對應(yīng)的數(shù)據(jù)。

class IntList{ }
class Floatlist{}
class DoubleList{}
class NumberList{}
......
更多

如果有更多的類型，就需要創(chuàng)建更多的集合類來保存對應(yīng)的數(shù)據(jù)，這顯示是不可能的，而泛型是一個 "萬能的類型匹配器"，同時有能讓編譯器保證類型安全。

泛型將具體的類型（ Int 、 Float 、 Double 等等）聲明的時候使用符號來代替，使用的時候，才指定具體的類型。

// 聲明的時候使用符號來代替
class List<E>{
}
// 在 Kotlin 中使用，指定具體的類型
val data1: List<Int> = List()
val data2: List<Float> = List()
// 在 Java 中使用，指定具體的類型
List<Integer> data1 = new List();
List<Float> data2 = new List();

泛型很好的幫我們解決了上面的問題，但是隨之而來出現(xiàn)了新的問題，我們都知道 Int 、 Float 、 Double 是 Number 子類型, 因此下面的代碼是可以正常運(yùn)行的。

// Kotlin
val number: Number = 1
// Java
Number number = 1;

我們花三秒鐘思考一下，下面的代碼是否可以正常編譯。

List<Number> numbers = new ArrayList<Integer>();

答案是不可以，正如下圖所示，編譯會出錯。

這也就說明了泛型是不可變的，IDE 認(rèn)為 ArrayList<Integer> 不是 List<Number> 子類型，不允許這么賦值，那么如何解決這個問題呢，這就需要用到協(xié)變了，協(xié)變允許上面的賦值是合法的。

Kotlin 和 Java 的協(xié)變

  • 在 Java 中用通配符 ? extends T 表示協(xié)變，extends 限制了父類型 T，其中 ? 表示未知類型，比如 ? extends Number，只要聲明時傳入的類型是 Number 或者 Number 的子類型都可以
  • 在 Kotlin 中關(guān)鍵字 out T 表示協(xié)變，含義和 Java 一樣

現(xiàn)在我們將上面的代碼修改一下，在花三秒鐘思考一下，下面的代碼是否可以正常編譯。

// kotlin
val numbers: MutableList<out Number> = ArrayList<Int>()
// Java
List<? extends Number> numbers = new ArrayList<Integer>();

答案是可以正常編譯，協(xié)變通配符 ? extends Number 或者 out Number 表示接受 Number 或者 Number 子類型為對象的集合，協(xié)變放寬了對數(shù)據(jù)類型的約束，但是放寬是有代價的，我們在花三秒鐘思考一下，下面的代碼是否可以正常編譯。

// Koltin
val numbers: MutableList<out Number> = ArrayList<Int>()
numbers.add(1)
// Java
List<? extends Number> numbers = new ArrayList<Integer>();
numbers.add(1)

調(diào)用 add() 方法會編譯失敗，雖然協(xié)變放寬了對數(shù)據(jù)類型的約束，可以接受 Number 或者 Number 子類型為對象的集合，但是代價是 無法添加元素，只能獲取元素，因此協(xié)變只能作為生產(chǎn)者，向外提供數(shù)據(jù)。

為什么無法添加元素

因為 ? 表示未知類型，所以編譯器也不知道會往集合中添加什么類型的數(shù)據(jù)，因此索性不允許往集合中添加元素。

但是如果想讓上面的代碼編譯通過，想往集合中添加元素，這就需要用到逆變了。

Kotlin 和 Java 的逆變

逆變其實是把繼承關(guān)系顛倒過來，比如 Integer 是 Number 的子類型，但是 Integer 加逆變通配符之后，Number 是 ? super Integer 的子類，如下圖所示。

  • 在 Java 中用通配符 ? super T 表示逆變，其中 ? 表示未知類型，super 主要用來限制未知類型的子類型 T，比如 ? super Number，只要聲明時傳入是 Number 或者 Number 的父類型都可以
  • 在 Kotlin 中關(guān)鍵字 in T 表示逆變，含義和 Java 一樣

現(xiàn)在我們將上面的代碼簡單修改一下，在花三秒鐘思考一下是否可以正常編譯。

// Kotlin
val numbers: MutableList<in Number> = ArrayList<Number>()
numbers.add(100)
// Java
List<? super Number> numbers = new ArrayList<Number>();
numbers.add(100);

答案可以正常編譯，逆變通配符 ? super Number 或者關(guān)鍵字 in 將繼承關(guān)系顛倒過來，主要用來限制未知類型的子類型，在上面的例子中，編譯器知道子類型是 Number，因此只要是 Number 的子類都可以添加。

逆變可以往集合中添加元素，那么可以獲取元素嗎？我們花三秒鐘時間思考一下，下面的代碼是否可以正常編譯。

// Kotlin
val numbers: MutableList<in Number> = ArrayList<Number>()
numbers.add(100)
numbers.get(0)
// Java
List<? super Number> numbers = new ArrayList<Number>();
numbers.add(100);
numbers.get(0);

無論調(diào)用 add() 方法還是調(diào)用 get() 方法，都可以正常編譯通過，現(xiàn)在將上面的代碼修改一下，思考一下是否可以正常編譯通過。

// Kotlin
val numbers: MutableList<in Number> = ArrayList<Number>()
numbers.add(100)
val item: Int = numbers.get(0)
// Java
List<? super Number> numbers = new ArrayList<Number>();
numbers.add(100);
int item = numbers.get(0);

調(diào)用 get() 方法會編譯失敗，因為 numbers.get(0) 獲取的的值是 Object 的類型，因此它不能直接賦值給 int 類型，逆變和協(xié)變一樣，放寬了對數(shù)據(jù)類型的約束，但是代價是 不能按照泛型類型讀取元素，也就是說往集合中添加 int 類型的數(shù)據(jù)，調(diào)用 get() 方法獲取到的不是 int 類型的數(shù)據(jù)。

對這一小節(jié)內(nèi)容，我們簡單的總結(jié)一下。

關(guān)鍵字（Java/Kotlin）添加讀取
協(xié)變? extends / out??
逆變? super  / in??

Kotlin 和 Java 數(shù)組協(xié)變的不同之處

無論是 Kotlin 還是 Java 它們協(xié)變和逆變的含義的都是一樣的，只不過通配符不一樣，但是他們也有不同之處。

Java 是支持?jǐn)?shù)組協(xié)變，代碼如下所示：

Number[] numbers = new Integer[10];

但是 Java 中的數(shù)組協(xié)變有缺陷，將上面的代碼修改一下，如下所示。

Number[] numbers = new Integer[10];
numbers[0] = 1.0;

可以正常編譯，但是運(yùn)行的時候會崩潰。

因為最開始我將 Number[] 協(xié)變成 Integer[]，接著往數(shù)組里添加了 Double 類型的數(shù)據(jù)，所以運(yùn)行會崩潰。

而 Kotlin 的解決方案非常的干脆，不支持?jǐn)?shù)組協(xié)變，編譯的時候就會出錯，對于數(shù)組逆變 Koltin 和 Java 都不支持。

協(xié)變和逆變的應(yīng)用場景

協(xié)變和逆變應(yīng)用的時候需要遵循 PECS（Producer-Extends, Consumer-Super）原則，即 ? extends 或者 out 作為生產(chǎn)者，? super 或者 in 作為消費(fèi)者。遵循這個原則的好處是，可以在編譯階段保證代碼安全，減少未知錯誤的發(fā)生。

協(xié)變應(yīng)用

  • 在 Java 中用通配符 ? extends 表示協(xié)變
  • 在 Kotlin 中關(guān)鍵字 out 表示協(xié)變

協(xié)變只能讀取數(shù)據(jù)，不能添加數(shù)據(jù)，所以只能作為生產(chǎn)者，向外提供數(shù)據(jù)，因此只能用來輸出，不用用來輸入。

在 Koltin 中一個協(xié)變類，參數(shù)前面加上 out 修飾后，這個參數(shù)在當(dāng)前類中 只能作為函數(shù)的返回值，或者修飾只讀屬性 ，代碼如下所示。

// 正常編譯
interface ProduceExtends<out T> {
    val num: T          // 用于只讀屬性
    fun getItem(): T    // 用于函數(shù)的返回值
}
// 編譯失敗
interface ProduceExtends<out T> {
    var num : T         // 用于可變屬性
    fun addItem(t: T)   // 用于函數(shù)的參數(shù) 
}

當(dāng)我們確定某個對象只作為生產(chǎn)者時，向外提供數(shù)據(jù)，或者作為方法的返回值時，我們可以使用 ? extends 或者 out。

  • 以 Kotlin 為例，例如 Iterator#next() 方法，使用了關(guān)鍵字 out，返回集合中每一個元素

  • 以 Java 為例，例如 ArrayList#addAll() 方法，使用了通配符 ? extends

傳入?yún)?shù) Collection<? extends E> c 作為生產(chǎn)者給 ArrayList 提供數(shù)據(jù)。

逆變應(yīng)用

  • 在 Java 中使用通配符 ? super 表示逆變
  • 在 Kotlin 中使用關(guān)鍵字 in 表示逆變

逆變只能添加數(shù)據(jù)，不能按照泛型讀取數(shù)據(jù)，所以只能作為消費(fèi)者，因此只能用來輸入，不能用來輸出。

在 Koltin 中一個逆變類，參數(shù)前面加上 in 修飾后，這個參數(shù)在當(dāng)前類中 只能作為函數(shù)的參數(shù)，或者修飾可變屬性 。

// 正常編譯，用于函數(shù)的參數(shù)
interface ConsumerSupper<in T> {
    fun addItem(t: T)
}
// 編譯失敗，用于函數(shù)的返回值
interface ConsumerSupper<in T> {
    fun getItem(): T
}

當(dāng)我們確定某個對象只作為消費(fèi)者，當(dāng)做參數(shù)傳入時，只用來添加數(shù)據(jù)，我們使用通配符 ? super 或者關(guān)鍵字 in，

  • 以 Kotlin 為例，例如擴(kuò)展方法 Iterable#filterTo()，使用了關(guān)鍵字 in，在內(nèi)部只用來添加數(shù)據(jù)

  • 以 Java 為例，例如 ArrayList#forEach() 方法，使用了通配符 ? super

不知道小伙伴們有沒有注意到，在上面的源碼中，分別使用了不同的泛型標(biāo)記符 T 和 E，其實我們稍微注意一下，在源碼中有幾個高頻的泛型標(biāo)記符 T 、 E 、 K 、 V 等等，它們分別應(yīng)用在不同的場景。

標(biāo)記符應(yīng)用場景
T（Type）類
E（Element）集合
K（Key）鍵
V（Value）值

以上就是Kotlin與Java 泛型缺陷和應(yīng)用場景詳解的詳細(xì)內(nèi)容，更多關(guān)于Kotlin Java 泛型缺陷的資料請關(guān)注腳本之家其它相關(guān)文章！

相關(guān)文章

最新評論