Was ist der Unterschied zwischen 'E', 'T' und '?' für Java-Generika?

Ich stoße auf Java-Code wie folgt:

public interface Foo<E> {}

public interface Bar<T> {}

public interface Zar<?> {}

Was ist der Unterschied zwischen allen drei oben genannten und wie nennen sie diese Art von Klassen- oder Schnittstellendeklarationen in Java?

Nun, es gibt keinen Unterschied zwischen den ersten beiden - sie verwenden nur unterschiedliche Namen für den Typparameter ( Eoder T).

Die dritte ist keine gültige Deklaration - ?wird als Platzhalter verwendet, der bei der Bereitstellung eines Typarguments verwendet wird , z. B. List<?> foo = ...bedeutet, dass fooauf eine Liste eines Typs verwiesen wird, aber wir wissen nicht, was.

All dies sind Generika , was ein ziemlich großes Thema ist. Möglicherweise möchten Sie dies anhand der folgenden Ressourcen erfahren, obwohl natürlich weitere verfügbar sind:

• Java Tutorial zu Generika
• Sprachführer für Generika
• Generika in der Programmiersprache Java
• Angelika Langers Java Generics FAQ (umfangreich und umfassend; mehr als Referenz)

Es ist mehr Konvention als alles andere.

• T soll ein Typ sein
• Esoll ein Element sein ( List<E>: eine Liste von Elementen)
• Kist der Schlüssel (in a Map<K,V>)
• V ist Wert (als Rückgabewert oder abgebildeter Wert)

Sie sind vollständig austauschbar (trotz Konflikten in derselben Erklärung).

Die vorherigen Antworten erläutern die Typparameter (T, E usw.), erklären jedoch nicht den Platzhalter "?" Oder die Unterschiede zwischen ihnen, daher werde ich darauf eingehen.

Um es klar zu machen: Die Platzhalter- und Typparameter sind nicht identisch. Wenn Typparameter eine Art Variable (z. B. T) definieren, die den Typ für einen Bereich darstellt, ist dies beim Platzhalter nicht der Fall: Der Platzhalter definiert nur eine Reihe zulässiger Typen, die Sie für einen generischen Typ verwenden können. Ohne Begrenzung ( extendsoder super) bedeutet der Platzhalter "hier einen beliebigen Typ verwenden".

Der Platzhalter steht immer in spitzen Klammern und hat nur im Zusammenhang mit einem generischen Typ eine Bedeutung:

public void foo(List<?> listOfAnyType) {...}  // pass a List of any type

noch nie

public <?> ? bar(? someType) {...}  // error. Must use type params here

oder

public class MyGeneric ? {      // error
    public ? getFoo() { ... }   // error
    ...
}

Es wird verwirrender, wo sie sich überschneiden. Beispielsweise:

List<T> fooList;  // A list which will be of type T, when T is chosen.
                  // Requires T was defined above in this scope
List<?> barList;  // A list of some type, decided elsewhere. You can do
                  // this anywhere, no T required.

Es gibt viele Überschneidungen bei den Methodendefinitionen. Die folgenden sind funktional identisch:

public <T> void foo(List<T> listOfT) {...}
public void bar(List<?> listOfSomething)  {...}

Also, wenn es Überlappungen gibt, warum das eine oder das andere verwenden? Manchmal ist es ehrlich gesagt nur Stil: Einige Leute sagen, wenn Sie keinen Typparameter benötigen , sollten Sie einen Platzhalter verwenden, um den Code einfacher / lesbarer zu machen. Ein Hauptunterschied, den ich oben erklärt habe: Typparameter definieren eine Typvariable (z. B. T), die Sie an anderer Stelle im Bereich verwenden können. der Platzhalter nicht. Ansonsten gibt es zwei große Unterschiede zwischen Typparametern und dem Platzhalter:

Typparameter können mehrere Begrenzungsklassen haben. Der Platzhalter kann nicht:

public class Foo <T extends Comparable<T> & Cloneable> {...}

Der Platzhalter kann Untergrenzen haben. Typparameter können nicht:

public void bar(List<? super Integer> list) {...}

Oben List<? super Integer>definiert das Integerals Untergrenze des Platzhalters, was bedeutet, dass der Listentyp Integer oder ein Supertyp von Integer sein muss. Generische Typbegrenzungen gehen über das hinaus, was ich im Detail behandeln möchte. Kurz gesagt, Sie können definieren, welche Typen ein generischer Typ sein kann. Dies ermöglicht die polymorphe Behandlung von Generika. ZB mit:

public void foo(List<? extends Number> numbers) {...}

Sie können einen Pass List<Integer>, List<Float>, List<Byte>etc. für numbers. Ohne Typbegrenzung funktioniert dies nicht - so sind Generika.

Schließlich ist hier eine Methodendefinition, die den Platzhalter verwendet, um etwas zu tun, von dem ich glaube, dass Sie es nicht anders machen können:

public static <T extends Number> void adder(T elem, List<? super Number> numberSuper) {
    numberSuper.add(elem);
}

numberSuperkann eine Liste der Zahlen oder ein beliebiger Supertyp der Zahl sein (z. B. List<Object>) und elemmuss Zahl oder ein beliebiger Untertyp sein. Bei allen .add()Einschränkungen kann der Compiler sicher sein, dass dies typsicher ist.

Eine Typvariable <T> kann ein beliebiger nicht primitiver Typ sein, den Sie angeben: ein beliebiger Klassentyp, ein beliebiger Schnittstellentyp, ein beliebiger Array-Typ oder sogar eine andere Typvariable.

Die am häufigsten verwendeten Typparameternamen sind:

• E-Element (wird häufig vom Java Collections Framework verwendet)
• K - Schlüssel
  
• N - Nummer
  
• T - Typ
  
• V - Wert
  

In Java 7 ist es erlaubt, wie folgt zu instanziieren:

Foo<String, Integer> foo = new Foo<>(); // Java 7
Foo<String, Integer> foo = new Foo<String, Integer>(); // Java 6

Die am häufigsten verwendeten Typparameternamen sind:

E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types

Diese Namen werden in der gesamten Java SE-API verwendet

Der Compiler erstellt für jeden Platzhalter (z. B. Fragezeichen in der Liste) eine Erfassung , wenn er eine Funktion wie die folgende bildet:

foo(List<?> list) {
    list.put(list.get()) // ERROR: capture and Object are not identical type.
}

Ein generischer Typ wie V wäre jedoch in Ordnung und würde ihn zu einer generischen Methode machen :

<V>void foo(List<V> list) {
    list.put(list.get())
}