Was sind Extends T und Super T in Java?

? Wildcard-Typ

• des Typs (Java wird in Core als Supertypqualifizierung bezeichnet), was bedeutet, dass der parametrisierte Typ der Supertyp (übergeordneter Typ) dieses Typs ist, bis Object;

• Obergrenze rein, kann aber nur herausgenommen werden

Zum Beispiel definieren wir jetzt: List

import java.util.LinkedList;
import java.util.List;

public class test {
    public static void main(String[] args) {
        List<? extends Father> list = new LinkedList<>();
        list.add(new Son());
    }
}
class Human{
}
class Father extends Human{
}
class Son extends Father{
}
class LeiFeng extends Father {
}

list.add(new Son()); Diese Zeile meldet einen Fehler: Die Methode put(Son) ist undefiniert für den Typ „List“ „eine Liste mit einem beliebigen Typ, der von „Son“ geerbt wurde, und kann daher keine Objekte sicher hinzufügen dazu. Sie können null hinzufügen, da null jeden Typ darstellen kann. Die Add-Methode von List kann also keine sinnvollen Elemente hinzufügen, kann aber bestehende Untertyp-List-Zuweisungen akzeptieren.

Sie können Folgendes versuchen:

List<? extends Father> list = new LinkedList<Son>();
list.add(new Son());

Auch wenn Sie den Son-Typ angeben, können Sie mit der Add-Methode kein Son-Objekt hinzufügen.

Warum können die Vaterklasse und die Unterklassen der Vaterklasse nicht zur Liste hinzugefügt werden?

List bedeutet, dass die Obergrenze Vater ist. Die folgenden Zuweisungen sind zulässig:

list1 kann Vater und alle Unterklassen hinzufügen.

list2 kann Son und alle Unterklassen von Son hinzufügen.

• list3 kann LeiFeng und alle Unterklassen von LeiFeng hinzufügen.

• Der folgende Code kann nicht kompiliert werden:

     List<? extends Father> list1 = new ArrayList<Father>();
     List<? extends Father> list2 = new ArrayList<Son>();
     List<? extends Father> list3 = new ArrayList<LeiFeng>();

Der Grund dafür ist, dass der Compiler nur weiß, dass der Container „Vater“ oder seine abgeleitete Klasse ist, aber den spezifischen Typ nicht kennt. Vielleicht Vater? Vielleicht Sohn? Vielleicht LeiFeng, XiaoMing? Nachdem der Compiler erkennt, dass „Vater“ später für die Zuweisung verwendet wird, ist der Parametertyp in der Sammlung nicht auf „Vater“ beschränkt. Markieren Sie es stattdessen mit einem Platzhalter: CAP#1, um die Erfassung eines Vaters oder einer Unterklasse von Vater anzuzeigen. Ich weiß nicht, um welche Klasse es sich genau handelt, daher trägt sie den Codenamen CAP#1. Unabhängig davon, ob Sie den Son-, LeiFeng- oder Father-Compiler einfügen möchten, wissen Sie nicht, ob er mit CAP # 1 übereinstimmen kann, und lassen dies daher nicht zu.

• Der Unterschied zwischen dem Platzhalterzeichen und Typparametern besteht also darin, dass für den Compiler alle T denselben Typ darstellen. In der folgenden generischen Methode beziehen sich beispielsweise die drei Ts alle auf denselben Typ, entweder String oder Integer.

  list1.add(new Father());//error
  list1.add(new Son());//error

Aber das Platzhalterzeichen hat keine solche Einschränkung. List bedeutet einfach: Es gibt etwas in der Sammlung, und ich weiß nicht, was es ist.

Der Fehler hier ist also, dass nichts in die Liste eingefügt werden kann.

List

public <T> List<T> fill(T... t);

Da wir außerdem sichergestellt haben, dass die Vaterklasse oder eine ihrer Unterklassen in der Liste gespeichert wird, können Sie die get-Methode verwenden, um den Wert direkt zu erhalten:

List<? extends Father> list1 = getFatherList();//getFatherList方法会返回一个Father的子类的list

Untergrenze

List<? extends Father> list1 = new ArrayList<>();
Father father = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。
Object object = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。
Human human = list1.get(0);//读取出来的东西只能存放在Father或它的基类里。
Son son = (Son)list1.get(0);

Da die Untergrenze die Untergrenze der minimalen Granularität des Elements angibt, lockert sie tatsächlich die Typkontrolle des Containerelements. Da das Element die Basisklasse von Father ist, kann es in einer kleineren Granularität als die von Father gespeichert werden. Aus Gründen der Typsicherheit können wir Vaterobjekte oder beliebige ihrer Unterklassen (z. B. Sohn) hinzufügen. Da der Compiler jedoch nicht weiß, welche Oberklasse von Vater der Inhalt der Liste ist, ist es nicht zulässig, eine bestimmte Oberklasse hinzuzufügen. Klasse (z. B. Mensch). Und wenn wir es lesen, kann der Compiler nur das Object-Objekt zurückgeben, ohne zu wissen, um welchen Typ es sich handelt, da Object die ultimative Vorgängerklasse jeder Java-Klasse ist. In diesem Fall gehen jedoch alle Typinformationen des Elements verloren.

PECS-Prinzip

Schauen wir uns abschließend an, was das PECS-Prinzip (Producer Extends Consumer Super) ist. Es ist bereits gut verstanden:

Wenn Sie häufig Inhalte von außen lesen, ist es geeignet, das zu verwenden obere Grenze Erstreckt sich.

Wenn Sie es häufig einführen, ist Nether Super geeignet.

Das obige ist der detaillierte Inhalt vonWas sind Extends T und Super T in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!