Java Generics (definiert Klassen und Methoden)

Informationen zur Syntax zum Definieren generischer Klassen und Methoden in Java. Begriffe finden Sie hier → Punkte von Java Generics

Temporärer Parameter

Wenn zum Beispiel `List <E>`, dann ist `` `Ein spitzen Klammern der formale Parameter. In Bezug auf die Grammatik gibt es kein Problem mit zwei oder mehr Zeichen oder einer Mischung aus Kleinbuchstaben, aber üblicherweise wird häufig ein Zeichen verwendet.Oder```JederelementOdertypeEs ist eine Abkürzung für.

Einschränkungen bei Pseudotypparametern

Es gibt einige Einschränkungen, da die Typparameterinformationen zur Laufzeit gelöscht werden. -- new T () `` `kann nicht gemacht werden -- new T [] `` `kann nicht gemacht werden -- T.class kann nicht referenziert werden -- obj Instanz von T kann nicht ausgewertet werden

So definieren Sie eine generische Klasse

Wenn Sie `SomeClass <T>` schreiben, können Sie den Typparameter `` `T``` in den Feldern der Klasse und in den Methoden (einschließlich Argumenten und Rückgabewerten) verwenden.

//↓ Schreiben Sie hier den Typparameter
public class SomeClass<T> {
  private T t;
  private List<T> list = new ArrayList<T>();
  public void set(T arg){
    this.t = arg;
  }
  public T get(){
    return this.t;
  }
}

Beachten Sie, dass die formalen Parameter einer generischen Klasse nicht in statischen Methoden oder statischen Anweisungen in dieser Klasse verwendet werden können, wie unten gezeigt.

public class Hoge<T>{
  static {
    T t; //Kompilierungsfehler
  }
  public static void hoge(T t){ //Kompilierungsfehler
  }
}

So definieren Sie eine generische Methode

Wenn Sie vor dem Rückgabetyp der Methode `<T>` schreiben, kann der Typparameter `` `T``` in der Methode verwendet werden.

  //↓ Schreiben Sie hier den Typparameter
  public static <T> ArrayList<T> someMethod(T arg){
    ArrayList<T> list = new ArrayList<T>();
    list.add(arg);
    return list;
  }

Das ist alles für die Grundlagen der generischen Klassendefinition und Methodendefinition, und dann werden wir den Inhalt des formalen Parameters `<T>` je nach Fall ändern.

Mehrere Typparameter

Sie können mehrere durch Kommas getrennte Typparameter verwenden.

  public static <K, V> HashMap<K, V> newHashMap(){
    return new HashMap<K, V>();
  }

  // ※<K,V>Die Art von wird von der linken Seite erraten
  Map<String, Integer> map = newHashMap();

Grenzparameter

<t erweitert Klassen und Schnittstellen>Wenn du gerne schreibsttKann erfordern, dass der Aufrufer eine Unterklasse der angegebenen Klasse (oder der angegebenen Klasse selbst) ist.

  //ArrayList, die nur mit der Unterklasse Number Type oder Number Type instanziiert werden kann
  public class NumArrayList<T extends Number> extends ArrayList<T> {}

  List<Number> numberList = new NumArrayList<Number>(); // ok
  List<Double> doubleList = new NumArrayList<Double>(); // ok
  List<String> stringList = new NumArrayList<String>(); //Kompilierungsfehler

Rekursive Grenze

In diesem Beispiel muss der Aufrufer angeben, dass E eine Implementierungsklasse von Comparable ist.

  //Methode zum Abrufen des Maximalwerts aus der Sammlung
  public static <E extends Comparable<E>> E max(Collection<E> collection) {
    //Code weggelassen. E ist compareTo(E)Weil es eine Methode hat
    //Sie können damit einen Algorithmus implementieren, der den Maximalwert eines Elements ermittelt.
  }

Mehrere Vererbungsspezifikationen

Um anzugeben, dass es sich um eine Implementierungsklasse mit mehreren Schnittstellen handelt, verbinden Sie die übergeordnete Klasse und die Schnittstellen mit `&`.

//Erfordert E, um sowohl vergleichbare als auch serialisierbare Schnittstellen zu implementieren
public class Fuga<E extends Comparable<E> & Serializable>{}

("& ``Ist ein sehr unbekanntes Symbol, aber ich verwende`` & ``, weil``, ``bereits als Typparameterbegrenzer verwendet wird. Ich glaube, dass der)