Lassen Sie uns über den generischen Mechanismus von Java sprechen

Interviewer: Erzählen Sie mir, was der generische Mechanismus von Java ist.

(Teilen von Lernvideos: Java-Video-Tutorial)

Antwort der Lite-Version

Bei der Entwicklung von Java verfügt eine Klasse, Schnittstelle oder Methode unter Verwendung der Diamantsyntax über eine Gruppe von Klassen, die eine allgemeine Referenz als akzeptieren Parameter: Die generische Klasse wird letztendlich durch die Regeln in spitzen Klammern definiert. Die generische Klasse wird normalerweise durch einen Großbuchstaben dargestellt, normalerweise den Buchstaben T. Nach der späteren Kompilierung durch den Java-Compiler wird der generische Typ gelöscht und entsprechend ersetzt Die verwendete spezifische Klasse generiert Klassenbytecode, sodass Generika für Jvm transparent sind.

Antwort zur Deluxe-Version

Generika wurden offiziell in JDK1.5 eingeführt

Java führte den Hintergrund von Generika ein

Java-Sammlungen ermöglichen die Eingabe mehrerer Typen, wie zum Beispiel

    List list=new ArrayList();
    list.add("String");
    list.add(1024);

Dies war vor JDK1.5 eine übliche Verwendung. Auch wenn es unter dem heutigen JDK platziert ist, ist es erlaubt, daher wird die Verwendung ähnlicher Sammlungen einige Probleme mit sich bringen, das heißt, welche Typen in der Sammlung platziert werden, weiß leider nur die Person, die die Sammlung erstellt hat, andere Anrufer können überhaupt nicht ermittelt werden. Daher ist es sehr wahrscheinlich, dass bei großen Projekten Probleme auftreten. Wenn der Aufrufer ein Objekt in der Sammlung zwangsweise überträgt, wird ein Fehler gemeldet Es wurde festgestellt, dass JDK Generika einführte, um ähnliche Probleme zu lösen.

Generischer Typ

Nach der Einführung von Generika ist es möglich, während der Kompilierungsphase zu überprüfen, ob der Typ den Anforderungen entspricht, wodurch eine blinde Typkonvertierung weitgehend entfällt. Generika funktionieren hauptsächlich im Compiler. Nach der Kompilierung kann die JVM keine Generika erkennen, wenn sie ausgeführt wird. Generika werden in gewöhnliche Generika und Wildcard-Generika unterteilt.

1. Gewöhnliche Generika

Wie der Name schon sagt, unterstützt diese Art von Generika die Übergabe aller Typen beim Aufruf, aber beim Aufruf müssen die Generika auf der linken und rechten Seite des Gleichheitszeichens konsistent sein. Die Raute auf der rechten Seite von JDK1.7 kann weggelassen werden.

class Test<T>{...} //声明时
Test<Integer> test = new Test<Integer>(); //调用时
Test<Integer> test = new Test(); //1.7调用时

3. Begrenzte Generika

<?>//无界泛型，任意类型都匹配
<T extends ClassA>//有界泛型 - 继承自某父类
<T extends InterfaceB>//有界泛型 - 实现某接口
<T extends ClassA & InterfaceB & InterfaceC ... >//有界泛型 - 多重边界
<T super ClassC>//有界泛型 - 指定类父类

Generika löschen

Generika funktionieren nur beim Schreiben von Code und beim Kompilieren, während die JVM-Ladeklasse beim Ausführen unempfindlich und transparent ist, da die Compiler-Generika beim Kompilieren gelöscht werden und im Großen und Ganzen werden die spitzen Klammern <> in der Klasse oder Methode entfernt und durch bestimmte Klassen gemäß den Regeln in den spitzen Klammern ersetzt, sodass der JVM überhaupt nicht ausgeführt wird Dies geschieht aus Kompatibilitätsgründen nur in JDK1.5. Auf diese Weise muss die vorhandene JVM nicht wesentlich geändert werden Art von Syntax, die der Compiler erkennen kann, die virtuelle Maschine jedoch nicht. Die Leute nennen diese Syntax Zucker (Suger). Nachdem der Compiler sie entfernt hat, überlässt er sie der virtuellen Maschine zur Ausführung.

(Empfohlenes Grafik-Tutorial: Java-Einführungs-Tutorial)

Generischer Löschmechanismus

//Pair的泛型
public class Pair<T> {

    private T mFirst;
    private T mSecond;

    public T getmFirst() {
        return mFirst;
    }

    public void setmFirst(T mFirst) {
        this.mFirst = mFirst;
    }

    public T getmSecond() {
        return mSecond;
    }

    public void setmSecond(T mSecond) {
        this.mSecond = mSecond;
    }
}

//Pair的原始类型
//无论何时定义一个泛型类型，都会自动提供一个相应的 原始类型
public class Pair {

    private Object mFirst;
    private Object mSecond;

    public Object getFirst() {
        return mFirst;
    }

    public void setFirst(Object mFirst) {
        this.mFirst = mFirst;
    }

    public Object getSecond() {
        return mSecond;
    }

    public void setmSecond(Object mSecond) {
        this.mSecond = mSecond;
    }
}

//如果调用Pair<T extends String>编译擦除后得到如下=
class Pair{
    private String mFirst;
    private String mSecond;
    ...
}

Wenn ein Generikum als Eingabeparameter einer Methode verwendet wird, wird es nach dem Löschen durch die Untergrenze eines Wildcard-Generikums ersetzt, z die Add-Methode

public static void insertElements(List<? super A> list){
    //Add进来的都是层级“小于等于”A的，也就是下界
    list.add(new A());
    list.add(new B());
    list.add(new C());
}

Wenn ein Generic als Rückgabeparameter einer Methode verwendet wird, wird es nach dem Löschen durch die Obergrenze eines Wildcard-Generikums ersetzt, wie z. B. die Get-Methode

public void processElements(List<? extends A> elements){
   //for循环挨个get list 里的数据，都当做A，也就是都当做上界
   for(A a : elements){
      System.out.println(a.getValue());
   }
}

Egal wie viel ich über den generischen Typ sage Löschung und wie viele Blogs ich lese, ist nicht so gut wie die offizielle Definition. Genau, hier ist ein Abschnitt des offiziellen Dokuments von Oracle zur Typlöschung

Das obige ist der detaillierte Inhalt vonLassen Sie uns über den generischen Mechanismus von Java sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!