Lassen Sie uns über die Kovarianz und Kontravarianz von Kotlin aus Java sprechen

Java Basic TutorialIn der heutigen Spalte werden Kovarianz und Kontravarianz in Kotlin vorgestellt.

Vorwort

Um Kovarianz und Kontravarianz in Kotlin und Java besser zu verstehen, werfen wir zunächst einen Blick auf einige Grundkenntnisse.

Normale Zuweisung

In Java lauten die üblichen Zuweisungsanweisungen wie folgt:

A a = b;复制代码

Die Bedingungen, die die Zuweisungsanweisung erfüllen muss, sind: Die linke Seite ist entweder die übergeordnete Klasse der rechten Seite oder vom gleichen Typ wie die rechte Seite Seite. Das heißt, der Typ von A muss „größer“ sein als der Typ von B, wie zum Beispiel Object o = new String("s"); . Der Einfachheit halber wird es im Folgenden als A > 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 就应该是 List 的子类呀！这是一个非常自然而然的想法！

但是很抱歉，由于种种原因，Java 并不支持。但是，Java 并不是完全抹杀了泛型的型变特性，Java 提供了 和 使泛型拥有协变和逆变的特性。

与

称为上界通配符， 称为下界通配符。使用上界通配符可以使泛型协变，而使用下界通配符可以使泛型逆变。

比如之前举的例子

List<Integer> l = new ArrayList<>();
List<Object> o = l;// 这里会报错，不能编译复制代码

如果使用上界通配符，

List<Integer> l = new ArrayList<>();
List<? extends Object> o = l;// 可以通过编译复制代码

这样，List 的类型就大于 List<Integer> 的类型了，也就实现了协变。这也就是所谓的“子类的泛型是泛型的子类”。

同样，下界通配符 可以实现逆变，如：

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

上述代码怎么就实现逆变了呢？首先，Object > Integer；另外，从前言我们知道，函数返回值类型必须大于实际返回值类型，在这里就是 List<? super Integer> > List<Object>

Zusätzlich zu den oben genannten häufigsten Zuweisungsanweisungen gibt es zwei weitere Zuweisungsanweisungen:

Zuweisung von Funktionsparametern

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

🎜Beim Aufruf der fun(b)-Methode wird it will Der übergebene Aktualparameter B b wird dem formalen Parameter A a zugewiesen, also in der Form A a = b. Ebenso muss der formale Parametertyp größer als der tatsächliche Parameter sein, d. h. A > 🎜

Zuweisung des Funktionsrückgabewerts🎜

Container<Object> c = new Container<String>(); // (1)编译报错Container<? extends Object> c = new Container<String>(); // (2)编译通过c.set("sss"); // (3)编译报错Object o = c.get();// (4)编译通过复制代码

🎜Der Funktionsrückgabewerttyp empfängt den Wert des tatsächlichen Rückgabetyps. Der tatsächliche Rückgabetyp B b entspricht der Zuweisung des Funktionsrückgabewerttyps A a, also B b, wird A a zugewiesen, also A a = b, dann muss die Typbeziehung von A > erfüllt sein. 🎜🎜Egal um welche Art von Aufgabe es sich handelt, sie muss den linken Typ > erfüllen. 🎜

Kovarianz und Kontravarianz in Java🎜🎜Mit den bisherigen Grundkenntnissen lassen sich Kovarianz und Kontravarianz leicht erklären. 🎜🎜Wenn Klasse A > Klasse B, trans(A) und trans(B), die nach einer Änderung von trans erhalten werden, immer noch trans(A) > erfüllen, dann werden sie als kovariante bezeichnet . 🎜🎜Inverse Variation ist genau das Gegenteil. Die nach einer Änderung erhaltenen trans(A) und trans(B) erfüllen trans(B) > inverse Änderung. 🎜🎜Jeder weiß zum Beispiel, dass Java-Arrays kovariant sind, dann kann A[] > Zum Beispiel: 🎜

Container<String> c = new Container<Object>(); // (1)编译报错Container<? super String> c = new Container<Object>(); // (2)编译通过
 c.set("sss");// (3) 编译通过
 String s = c.get();// (4) 编译报错复制代码

🎜Aber Javas Generika erfüllen die Kovarianz nicht, wie folgt: 🎜

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

🎜Der obige Code meldet einen Fehler, da die Generika trotz Objekt > Ganzzahl nicht die Kovarianz erfüllen, also List > List<Integer> ist nicht erfüllt. Da die Bedingung, dass die linke Seite größer als die rechte Seite ist, nicht erfüllt ist, wissen wir aus dem Vorwort, dass List<Integer> zum Auflisten. Es wird allgemein gesagt, dass Java-Generika keine Typvariation unterstützen. 🎜

So implementieren Sie Kovarianz und Kontravarianz mit Generika in Java🎜🎜Von vornherein wissen wir, dass Generika in Java keine Typvariation unterstützen, aber dies führt zu einem Problem, das die Leute verwirrt . Ein sehr seltsamer Zweifel, der auch in vielen Artikeln über Generika erwähnt wird: 🎜🎜Wenn B eine Unterklasse von A ist, dann sollte List eine Unterklasse von List sein! Das ist eine sehr natürliche Idee! 🎜🎜Aber leider wird Java aus verschiedenen Gründen nicht unterstützt. Allerdings löscht Java die variablen Eigenschaften von Generika nicht vollständig aus. Java erweitert T> um Super-T> 🎜

werden als obere Grenze bezeichnet; Platzhalter. Verwenden Sie Platzhalter für die Obergrenze, um Generika kovariant zu machen, und Platzhalter für die Untergrenze, um Generika kontravariant zu machen. 🎜🎜Zum Beispiel im vorherigen Beispiel 🎜

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

🎜Wenn Sie den Platzhalter für die Obergrenze verwenden, 🎜

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

val c: Container<Any> = Container<String>()// （2）编译通过，因为 T 是一个 out-参数复制代码

🎜Auf diese Weise ist der Typ von List größer als der Typ von List<Integer>, wodurch erreicht wird Kovarianz. Dies nennt man „Eine Unterklasse eines Generikums ist eine Unterklasse eines Generikums.“ 🎜🎜In ähnlicher Weise kann das untere Platzhalterzeichen

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-参数复制代码

Nach dem Login kopieren

🎜Wie kann der obige Code eine Inversion erreichen? Zunächst wissen wir aus dem Vorwort, dass der Rückgabewerttyp der Funktion größer sein muss als der tatsächliche Rückgabewerttyp ; List<Object>, genau das Gegenteil von Object > Mit anderen Worten, nach der generischen Änderung wird die Typbeziehung zwischen Objekt und Ganzzahl umgekehrt. Dies ist Kontravarianz, und was Kontravarianz implementiert, ist der untere Grenzwert Super T>. 🎜🎜Wie aus dem Obigen hervorgeht, ist die Obergrenze in , was bedeutet, dass die Typen, auf die im Allgemeinen mit Bezug genommen wird, Unterklassen von T oder T selbst sind als < Die untere Grenze in ist die im Allgemeinen mit bezeichnete Klasse T. 🎜

虽然 Java 使用通配符解决了泛型的协变与逆变的问题，但是由于很多讲到泛型的文章都晦涩难懂，曾经让我一度感慨这 tm 到底是什么玩意？直到我在 stackoverflow 上发现了通俗易懂的解释(是的，前文大部分内容都来自于 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