Möglichkeit, einer Klassenmethode, die einen beliebigen Typ akzeptiert, einen bestimmten Typ zuzuweisen und eine typspezifische Klasse zu generieren **
Jetzt können Sie ** den Typ des Elementelements zur Kompilierungszeit garantieren **
Beispiel: Deklarieren Sie den Typparameter E public class ArrayList <E> erweitert AbstractList <E> {
** Typparameter **: Teil der Deklaration <...>, um einen bestimmten Typ zu erhalten
Weisen Sie der Instanz einen beliebigen Typ zu
** T (Typ) ** ・ ** E (Element) ** ・ ** K (Schlüssel) **, ** V (Wert) **
** Typvariable **: Der im Typparameter deklarierte Typ
Argument / Rückgabewert des Instanzmitglieds
Lokaler Variablentyp
Verschachtelter Typ
In Generics wird ArrayList
** Löschen **: Konvertieren unnötiger Typinformationen zur Laufzeit zur Kompilierungszeit auf diese Weise in Objekttyp
** Tatsächlicher Typparameter (Typargument) **: Spezifischer Typ, der beim Instanziieren eines generischen Typs angegeben wird (Ganzzahl usw.)
new ArrayList**<Integer>**：
** Parametrisierter Typ **: Ein generischer Typ, dem ein bestimmter Typ durch ein Typargument zugewiesen wird (z. B. ArrayList ).
new **ArrayList<Integer>**：
Geben Sie Parametereinschränkungen ein
** Ich möchte annehmen, dass die Methode einige Argumente hat **
Im folgenden Beispiel tritt ein Fehler auf, da die Variablen x und y vom Typ T nicht immer über eine compareTo-Methode verfügen.
Klassen wie String, Integer, File, die die Schnittstelle = Comparable mit der compareTo-Methode implementieren
//Error
public class GenericConstraint <T> {
public int Hoge(T x, T y) {
return x.compareTo(y);
}
}
→ ** Einschränkung (Grenztyp) mit Typparameter hinzufügen **
<Typparameter erweitert Grenztyp, ..>
Typparameter mit ingBuilder-Grenztyp werden beim Kompilieren ** in den Grenztyp anstelle des Objekttyps konvertiert **
Zeichenfolgentypen, die die unten gezeigte Schnittstelle Comparable implementieren, können an die GenericConstraint-Klasse übergeben werden.
//Ein Beispiel für das Erkennen der compareTo-Methode
public class GenericConstraint <T extends Comparable<T>> {
public int Hoge(T x, T y) {
return x.compareTo(y);
}Shi
}
Grenztyp ist ** Klasse / Schnittstelle kann angegeben werden **
erweitert ** statt * implementiert
** Es können mehrere Schnittstellen angegeben werden **
** Nur eine Klasse ** (oder 0)
** Beschrieben in der Reihenfolge Klasse → Schnittstelle **
public class MyGeneric <T extends Hoge & Bar $ Foo> {
Generischer Methodenkonstruktor
Eine Methode oder ein Konstruktor, der / der ** Typen wie Argumente / Rückgabewerte / lokale Variablen zum Zeitpunkt des Aufrufs bestimmt **
Generische Methoden sind ** unabhängig von generischen Typen, daher können auch nicht generische Typen definiert werden **
[Qualifikation]<Geben Sie Parameter ein>Geben Sie den Methodennamen des Typs zurück(Argumenttyp Argumentname, ...)
[Throw-Klausel]{
Methodenkörper
}
Grenz-Wildcard-Typ
** Covariant **: ** Array ** kann abgeleitete Klasse der Basisklasse zuweisen Child [] kann Parent [] zugewiesen werden, wenn Parent / Child eine Vererbungsbeziehung hat
Object[] data = new String[5];
Da Object / String eine Vererbungsbeziehung hat, kann ein String-Array zugewiesen werden, um den Objekttyp einzugeben.
Da der tatsächliche Status der Daten in data [1] = 10; String [] ist, ArrayStoreException
** invariant **: ** Generics ** Sammlung
ArrayList kann ArrayList nicht zugewiesen werden, selbst wenn Eltern / Kind eine Vererbungsbeziehung haben
ArrayList <Objekt> data = new ArrayList <String> (); // Fehler
//NG Beispiel
import java.util.List;
public class GenericBounded {
//List<Parent>Empfängt und gibt eine Liste von Typen aus
public void show(List<Parent> list) {
for (var p : list) {
System.out.println(p.getName());
}
}
}
import java.util.ArrayList;
import java.util.Arrays;
public class GenericBoundedBasic {
public static void main(String[] args) {
var cli = new GenericBounded();
var data1 = new ArrayList<Parent>(Arrays.asList(
new Parent("Frosch"), new Parent("Niwatori"), new Parent("Libelle")));
var data2 = new ArrayList<Child>(Arrays.asList(
new Child("Otamajakushi"), new Child("Küken"), new Child("Yago")));
cli.show(data1); //OK
//List<Parent>Liste als Typargument<Child>Typwerte können nicht übergeben werden
cli.show(data2); //Kompilierungsfehler
}
}
Da show eine Methode ist, die sich auf den Inhalt der Liste bezieht, erfolgt keine Wertzuweisung.
→ ** Boundary Wildcard ** erlaubt den Elterntyp oder seinen Ableitungstyp (Kovariante)
Der Typ List kann als Argument vom Typ List übergeben werden
Elemente können nicht hinzugefügt oder aktualisiert werden
Der Platzhalter-Grenztyp kann sich nur auf Werte mit dem ** Randtyp ** beziehen
import java.util.List;
public class GenericBounded {
//Grenz-Platzhalter
public void show(List<? extends Parent> list) {
for (var p : list) {
System.out.println(p.getName());
}
}
}
Beispiel für eine Standardbibliothek
ArrayList.java
public boolean addAll(Collection<? extends E> c){
Object[] a = c.toArray();
//Abkürzung
}
Werte wie ArrayList , ArrayList können nicht zum ArrayList -Typ hinzugefügt werden, wenn sie als "addAll (Collection c" "definiert sind.
Unter Verwendung des Begrenzungs-Platzhalters ** Der Elementtyp der als Argument übergebenen Liste kann CharSequence / seinen Ableitungstyp akzeptieren **
Platzhalter für die untere Grenze
** Platzhalter für Obergrenze : Obergrenze des angegebenen Grenztyps, akzeptiert Untertypen ( <? Erweitert E> **)
** ** Platzhalter für die untere Grenze : Der Basistyp kann an den Schäkeltyp übergeben werden = ** Inversion ** ( <? Super T> **)
In der addAll-Methode kann der Wildcard-Typ "Collection <? Super T>" für die untere Grenze eine Sammlung übergeben, die ** Typ T oder einen höheren Typ als Element hat **
Wenn addAll keinen Platzhalter mit niedrigerer Grenze hätte, müsste das Hinzufügen eines Elements vom Typ String "ArrayList " sein
Für Argumente (Produzent), die nur den Wert ** Oberer Platzhalter ** erhalten
Für Argumente (Verbraucher), die nur einen Wert festlegen ** Platzhalter für die untere Grenze **
java:java.util.Collections.addAll.java
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
boolean result = false;
for (T element : elements)
result |= c.add(element);
return result;
}
//ArrayList<Object>Ermöglicht das Hinzufügen von Elementen vom Typ String für
import java.util.ArrayList;
import java.util.Collections;
public class LowerBoundedBasic {
public static void main(String[] args) {
var list = new ArrayList<Object>();
Collections.addAll(list, "neko", "inu", "tori");
System.out.println(list); //[neko, inu, tori]
}
}
Platzhalter ohne Grenzen
Hat keinen Randtyp
Geben Sie als "Liste <?>" An
Hinweis: Zur Gewährleistung der Schimmelpilzsicherheit
** Methode, die T als Argument verwendet, kann nicht aufgerufen werden **
** Alle T, die den Rückgabewert der Methode darstellen, sind vom Objekttyp **
import java.util.List;
public class UnBounded {
public static void showList(List<?> list) {
for (var item : list) {
System.out.println(item);
}
//list.add("Hoge");//Der Wert kann nicht übergeben werden, da der Typ nicht festgelegt ist
//list.add(null); //Ausnahmsweise null ist OK
// Object obj = list.get(0); //Das erhaltene Ergebnis ist kein String-Typ, sondern ein Objekttyp!!
}
}