public void printPair( Paar<String,Long><\/span> <\/b> Paar) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Paar<String,Long><\/span> <\/b> limit = neu Paar<String,Long><\/span> <\/b> (\u201emaximal\u201c,1024L);<\/tt>
\n printPair(limit);<\/tt><\/p><\/blockquote>\nBeispiel (f\u00fcr einen mit Platzhaltern parametrisierten Typ):<\/p>\n
\n public void printPair( Paar<?,?><\/span> <\/b> Paar) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Paar<?,?><\/span> <\/b> limit = neu Paar<String,Long><\/span> <\/b> (\u201emaximal\u201c,1024L);<\/tt>
\n printPair(limit);<\/tt><\/p><\/blockquote>\n<\/blockquote>\nAlle Instanziierungen eines generischen Typs verwenden dieselbe Laufzeittypdarstellung, n\u00e4mlich die Darstellung des Rohtyps. Zum Beispiel die Instanziierungen eines generischen Typs Liste<\/tt> , wie zum Beispiel List<Date><\/tt> , List<String><\/tt> , List<Long><\/tt> usw. haben zur Kompilierungszeit unterschiedliche statische Typen, aber denselben dynamischen Typ Liste <\/tt> zur Laufzeit.<\/p>\n
Eine Besetzung besteht aus zwei Teilen:<\/p>\n
\n- eine vom Compiler zur Kompilierungszeit durchgef\u00fchrte statische Typpr\u00fcfung und<\/li>\n
- eine dynamische Typpr\u00fcfung, die von der virtuellen Maschine zur Laufzeit durchgef\u00fchrt wird.<\/li>\n<\/ul>\n
Der statische Teil sortiert unsinnige Casts aus, die nicht erfolgreich sein k\u00f6nnen, wie zum Beispiel der Cast from Zeichenfolge<\/tt> Das Datum<\/tt> oder von List<String><\/tt> Das List<Date><\/tt> .<\/p>\n
Der dynamische Teil verwendet die Laufzeittypinformationen und f\u00fchrt zur Laufzeit eine Typpr\u00fcfung durch.\u00a0 Es erh\u00f6ht a ClassCastException<\/tt> wenn der dynamische Typ des Objekts nicht der Zieltyp (oder ein Untertyp des Zieltyps) der Umwandlung ist. Beispiele f\u00fcr Besetzungen mit dynamischem Anteil sind die Besetzung von Objekt<\/tt> Das Zeichenfolge<\/tt> oder von Objekt<\/tt> Das List<String><\/tt> .\u00a0 Dies sind die sogenannten Downcasts, von einem Supertyp bis hin zu einem Subtyp.<\/p>\n
Beispiele f\u00fcr konkrete parametrisierte Typen sind List<String><\/tt> , Map<String,Date><\/tt> , aber nicht List<? erweitert Number><\/tt> oder Map<String,?><\/tt> .<\/p>\n
Manchmal wird erwartet, dass a List<Object><\/tt> w\u00e4re ein Supertyp von a List<String><\/tt> , Weil Objekt<\/tt> ist ein Supertyp von Zeichenfolge<\/tt> .\u00a0 Diese Erwartung ergibt sich aus der Tatsache, dass f\u00fcr Arrays eine solche Art von Beziehung existiert:\u00a0 Objekt[]<\/tt> ist ein Supertyp von String[]<\/tt> , Weil Objekt<\/tt> ist ein Supertyp von Zeichenfolge<\/tt> . (Diese Art von Beziehung ist bekannt als Kovarianz<\/i> .) Die Super-Subtyp-Beziehung der Komponententypen erstreckt sich bis in die entsprechenden Array-Typen. F\u00fcr Instanziierungen generischer Typen existiert keine solche Typbeziehung. (Parametrierte Typen sind nicht<\/i> kovariante.)<\/p>\n
Das Fehlen einer Super-Subtyp-Beziehung zwischen Instanziierungen desselben generischen Typs hat verschiedene Konsequenzen.\u00a0 Hier ist ein Beispiel.<\/p>\n
Beispiel:<\/p>\n
void printAll(ArrayList<Object> c) {<\/tt>
\n \u00a0 for (Objekt o : c)\u00a0<\/tt>
\n \u00a0\u00a0\u00a0 System.out.println(o);<\/tt>
\n }<\/tt> ArrayList<String> list = new ArrayList<String>();<\/tt>
\n ... Liste ausf\u00fcllen ...<\/tt>
\n printAll(list);\u00a0\u00a0 \/\/ Fehler<\/tt><\/p>\n
A ArrayList<String><\/tt> Das Objekt kann nicht als Argument an eine Methode \u00fcbergeben werden, die nach einem fragt ArrayList<Object><\/tt> weil die beiden Typen Instanziierungen desselben generischen Typs sind, aber f\u00fcr anders<\/i> Typargumente und aus diesem Grund sind sie nicht miteinander kompatibel.<\/p>\n
Konkrete parametrisierte Typen sind konkrete Instanziierungen eines generischen Typs.\u00a0 Sie sind fast wie Typen; Es gibt nur wenige Einschr\u00e4nkungen.\u00a0 Sie d\u00fcrfen NICHT f\u00fcr folgende Zwecke verwendet werden:<\/p>\n
\n- zur Erstellung von Arrays<\/li>\n
- in der Ausnahmebehandlung<\/li>\n
- in einem Klassenliteral<\/li>\n
- in einem Instanz von<\/tt> Ausdruck<\/li>\n<\/ul>\n
Arrays, die Elemente enthalten, deren Typ ein konkreter parametrisierter Typ ist, sind unzul\u00e4ssig.<\/p>\n
Beispiel (f\u00fcr einen unzul\u00e4ssigen Array-Typ):<\/p>\n
static void test() {<\/tt>
\n \u00a0 Paar<Integer,Integer>[]<\/span> <\/b> intPairArr = neu Paar<Integer,Integer>[10]<\/span> <\/b> ; \/\/ Fehler<\/span> <\/b> <\/tt>
\n \u00a0 addElements(intPairArr);\u00a0<\/tt>
\n \u00a0 Pair<Integer,Integer> pair = intPairArr[1];<\/tt>
\n \u00a0 Ganzzahl i = pair.getFirst();<\/tt>
\n \u00a0 pair.setSecond(i);<\/tt>
\n }<\/tt>
\n static void addElements( Objekt[]<\/b> objArr) {<\/tt>
\n \u00a0 objArr[0] = neues Pair<Integer,Integer>(0,0);<\/tt>
\n \u00a0 objArr[1] = neues Pair<String,String>(\"\",\"\");\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ sollte mit ArrayStoreException fehlschlagen<\/tt>
\n }<\/tt><\/p>\nDer Compiler verbietet die Erstellung von Arrays, deren Komponententyp ein konkreter parametrisierter Typ ist, z Paar<Integer,Integer><\/tt> in unserem Beispiel.\u00a0 Wir haben im vorherigen Eintrag besprochen, warum es sinnvoll ist, dass der Compiler a qualifiziert Paar<Integer,Integer>[]<\/tt> <\/span> als illegal.\u00a0 Das Hauptproblem besteht darin, dass der Compiler und das Laufzeitsystem sicherstellen m\u00fcssen, dass ein Array ein ist homogen<\/i> Folge von Elementen des gleichen Typs.\u00a0 Eine der Typpr\u00fcfungen, n\u00e4mlich die von der virtuellen Maschine zur Laufzeit durchgef\u00fchrte Array-Store-Pr\u00fcfung, erkennt das fehlerhafte Einf\u00fcgen eines fremden Elements nicht. Im Beispiel die zweite Einf\u00fcgung im addElements<\/tt> Die Methode sollte fehlschlagen, da ein Zeichenfolgenpaar zu einem Array ganzzahliger Werte hinzugef\u00fcgt wurde, aber sie schl\u00e4gt nicht wie erwartet fehl. Die Gr\u00fcnde wurden im vorherigen Eintrag besprochen.<\/p>\nWenn wir keine Arrays verwenden k\u00f6nnen, die Elemente enthalten, deren Typ ein konkreter parametrisierter Typ ist, was k\u00f6nnen wir dann als Workaround verwenden?<\/p>\n
Betrachten wir drei denkbare Workarounds:<\/p>\n
\n- Array von Rohtypen<\/li>\n
- Array eines unbegrenzten, mit Platzhaltern parametrisierten Typs<\/li>\n
- Sammlung statt Array<\/li>\n<\/ul>\n
W\u00e4hrend Arrays konkreter parametrisierter Typen unzul\u00e4ssig sind, sind Sammlungen konkreter parametrisierter Typen zul\u00e4ssig.<\/p>\n
Ein parametrisierter Platzhaltertyp ist eine Instanziierung eines generischen Typs, bei dem mindestens ein Typargument ein Platzhalter ist.\u00a0 Beispiele f\u00fcr mit Platzhaltern parametrisierte Typen sind: Sammlung<?><\/tt> , List<? erweitert Number><\/tt> , Komparator<? super String><\/tt> Und Paar<String,?><\/tt> . Ein mit Platzhalterzeichen parametrisierter Typ bezeichnet eine Typfamilie, die konkrete Instanziierungen eines generischen Typs umfasst.\u00a0 Die Art des verwendeten Platzhalters bestimmt, welche konkreten parametrisierten Typen zur Familie geh\u00f6ren.\u00a0 Zum Beispiel der mit Platzhaltern parametrisierte Typ Sammlung<?><\/tt> bezeichnet die Familie aller Instanziierungen der Sammlung<\/tt> Schnittstelle unabh\u00e4ngig vom Typargument.\u00a0 Der mit Platzhaltern parametrisierte Typ List<? erweitert Number><\/tt> bezeichnet die Familie aller Listentypen, bei denen der Elementtyp ein Untertyp von ist\u00a0 Nummer<\/tt> .\u00a0 Der mit Platzhaltern parametrisierte Typ Komparator<? super String><\/tt> ist die Familie aller Instanziierungen der Komparator<\/tt> Schnittstelle f\u00fcr Typargumenttypen, die Supertypen von sind Zeichenfolge.<\/tt><\/p>\n
Ein mit Platzhaltern parametrisierter Typ ist kein Typ im regul\u00e4ren Sinne (anders als eine nicht parametrisierte Klasse\/Schnittstelle oder ein Rohtyp).<\/em> <\/strong><\/p>\nF\u00fcr die Typisierung k\u00f6nnen parametrisierte Wildcard-Typen verwendet werden (wie nicht parametrisierte Klassen und Schnittstellen):<\/p>\n
\n- als Argument- und R\u00fcckgabetypen von Methoden<\/li>\n
- als Typ eines Feldes oder einer lokalen Referenzvariablen<\/li>\n
- als Komponententyp eines Arrays, als Typargument anderer parametrisierter Typen<\/li>\n
- als Zieltyp in Casts<\/li>\n<\/ul>\n
Nicht nur Typen k\u00f6nnen generisch sein, sondern auch Methoden. Statische und nicht statische Methoden sowie Konstruktoren k\u00f6nnen Typparameter haben. Die Syntax zur Deklaration der formalen Typparameter \u00e4hnelt der Syntax f\u00fcr generische Typen. Der Typparameterabschnitt wird durch spitze Klammern begrenzt und erscheint vor dem R\u00fcckgabetyp der Methode. Seine Syntax und Bedeutung ist identisch mit der Typparameterliste eines generischen Typs.<\/p>\n
Hier ist das Beispiel eines Generikums max<\/tt> Methode, die den gr\u00f6\u00dften Wert in einer Sammlung von Elementen eines unbekannten Typs berechnet A<\/tt> .<\/p>\n
Beispiel (einer generischen Methode):<\/p>\n
Klassensammlungen {<\/tt>
\n \u00a0 \u00f6ffentliche statische Aufladung <A erweitert Comparable<A>> A<\/span> <\/b> max(Collection< A<\/span> <\/b> > xs) {<\/tt>
\n \u00a0\u00a0\u00a0 Iterator< A<\/span> <\/b> > xi = xs.iterator();<\/tt>
\n \u00a0\u00a0\u00a0 A<\/span> <\/b> w = xi.next();<\/tt>
\n \u00a0\u00a0\u00a0 while (xi.hasNext()) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 A<\/span> <\/b> x = xi.next();<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 if (w.compareTo(x) < 0) w = x;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0 return w;<\/tt>
\n \u00a0 }<\/tt>
\n }\u00a0<\/tt><\/p><\/blockquote>\nDer max<\/tt> Die Methode verf\u00fcgt \u00fcber einen Typparameter mit dem Namen A<\/tt> .\u00a0 Es handelt sich um einen Platzhalter f\u00fcr den Elementtyp der Sammlung, mit der die Methode arbeitet. Der Typparameter hat eine Grenze; Es muss ein Typ sein, der ein Untertyp von ist Vergleichbar<A><\/tt><\/p>\n
Beispiel (diesmal vom gleichen generischen Typ). mit<\/i> Grenzen):<\/p>\n \u00f6ffentliche Schnittstelle Comparable<T> {<\/tt>
\n \u00a0 public int CompareTo(T arg);<\/tt>
\n }<\/tt>
\n \u00f6ffentliche Klasse TreeMap<Key erweitert Comparable<Key><\/span> <\/b> ,Data>{<\/tt>
\n \u00a0 private statische Klasse Entry<K,V> {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 K-Taste;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 V-Wert;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Eintrag<K,V> left = null;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Eintrag<K,V> right = null;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Eintrag<K,V> \u00fcbergeordnetes Element;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 privater transienter Eintrag<Key,Data> root = null;<\/tt>
\n \u00a0 ...<\/tt>
\n \u00a0 private Entry<Key,Data> getEntry(Key key) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Entry<Key,Data> p = root;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Schl\u00fcssel k = Schl\u00fcssel;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 while (p != null) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 int cmp = k. CompareTo(p.key)<\/span> <\/b> ;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 if (cmp == 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 R\u00fcckkehr p;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 sonst wenn (cmp < 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 p = p.links;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 anders\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 p = p.rechts;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 null zur\u00fcckgeben;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 \u00f6ffentlicher boolescher Wert enth\u00e4ltSchl\u00fcssel(Schl\u00fcsselschl\u00fcssel) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 return getEntry(key) != null;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\nIm obigen Beispiel der Typparameter Schl\u00fcssel<\/tt> hat die Grenze Vergleichbar<Key><\/tt> .\u00a0 Die Angabe einer Grenze hat zwei Auswirkungen:<\/p>\n\n- Es erm\u00f6glicht den Zugriff auf die Methoden, die die Grenze angibt<\/i> .\u00a0 Im Beispiel die Grenze Vergleichbar<Key> <\/tt> erm\u00f6glicht den Zugriff auf die vergleichenMit<\/tt> Methode, die wir bei der Implementierung unserer aufrufen m\u00f6chten TreeMap<\/tt> Klasse.<\/li>\n<\/ul>\n
\n- F\u00fcr die Instanziierung des generischen Typs k\u00f6nnen nur Typen \u201einnerhalb der Grenzen\u201c verwendet werden.<\/i> \u00a0 Im Beispiel ist ein parametrisierter Typ wie z TreeMap<Number,String><\/tt> w\u00fcrde abgelehnt werden, weil der Typ Nummer<\/tt> ist kein Subtyp von Vergleichbar<Number><\/tt> .\u00a0 Ein parametrisierter Typ wie TreeMap<String,String><\/tt> w\u00fcrde akzeptiert, da der Typ String innerhalb der Grenzen liegt, d. h. ein Subtyp von ist Vergleichbar<String><\/tt> .<\/li>\n<\/ul>\n
Alle Klassen, Schnittstellen und Aufz\u00e4hlungstypen k\u00f6nnen als Typparameterbindung verwendet werden, einschlie\u00dflich verschachtelter und innerer Typen.\u00a0 Weder primitive Typen noch Array-Typen k\u00f6nnen als Typparameterbindung verwendet werden.<\/p>\n
Beispiele (f\u00fcr Typparametergrenzen):<\/p>\n
Klasse X0 <T erweitert int<\/span> <\/b> > { ... }\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ Fehler<\/span> <\/b> <\/tt>
\n Klasse X1 <T erweitert Objekt[]<\/span> <\/b> > { ... } \/\/ Fehler<\/span> <\/b> <\/tt>
\n Klasse X2 <T erweitert Nummer<\/span> <\/b> > { ... }<\/tt>
\n Klasse X3 <T erweitert Zeichenfolge<\/span> <\/b> > { ... }<\/tt>
\n Klasse X4 <T erweitert Lauff\u00e4hig<\/span> <\/b> > { ... }<\/tt>
\n Klasse X5 <T erweitert Thread.State<\/span> <\/b> > { ... }<\/tt>
\n Klasse X6 <T erweitert Liste<\/span> <\/b> > { ... }<\/tt>
\n Klasse X7 <T erweitert List<String><\/span> <\/b> > { ... }<\/tt>
\n Klasse X8 <T erweitert List<? erweitert Number><\/span> <\/b> > { ... }<\/tt>
\n Klasse X9 <T erweitert Vergleichbar<? super Number><\/span> <\/b> > { ... }<\/tt>
\n Klasse X10<T erweitert Map.Entry<?,?><\/span> <\/b> > { ... }<\/tt><\/p><\/blockquote>\nDas Codebeispiel zeigt, dass primitive Typen wie z int<\/tt> und Array-Typen wie Objekt[] <\/tt> sind als Typparameterbindung nicht zul\u00e4ssig.<\/p>\n
Klassentypen, wie z Nummer<\/tt> oder Zeichenfolge<\/tt> , und Schnittstellentypen, wie z Lauff\u00e4hig<\/tt> , sind als Typparameterbindung zul\u00e4ssig.<\/p>\n
Aufz\u00e4hlungstypen, wie z Thread.State<\/tt> sind auch als Typparameterbindung zul\u00e4ssig. Thread.State<\/tt> ist ein Beispiel f\u00fcr einen verschachtelten Typ, der als Typparameterbindung verwendet wird.\u00a0 Auch nichtstatische Innentypen sind zul\u00e4ssig.<\/p>\n
Rohtypen sind als Typparameterbindung zul\u00e4ssig; Liste<\/span> <\/tt> ist ein Beispiel.<\/p>\nParametrisierte Typen sind als Typparameterbindung zul\u00e4ssig, einschlie\u00dflich konkreter parametrisierter Typen wie z List<String><\/tt> , begrenzte Wildcard-parametrisierte Typen wie z List<? erweitert Number><\/tt> Und Vergleichbar<? super Long><\/tt> und unbegrenzte, mit Platzhaltern parametrisierte Typen wie z Map.Entry<?,?><\/tt> .\u00a0 Eine Grenze, bei der es sich um einen parametrisierten Platzhaltertyp handelt, l\u00e4sst als Typargument alle Typen zu, die zu der Typfamilie geh\u00f6ren, die der Platzhalter bezeichnet.\u00a0 Die durch Platzhalter parametrisierte Typbindung gew\u00e4hrt nur eingeschr\u00e4nkten Zugriff auf Felder und Methoden. Die Einschr\u00e4nkungen h\u00e4ngen von der Art des Platzhalters ab.<\/p>\n
Beispiel (f\u00fcr einen mit Platzhalterzeichen parametrisierten Typ als Typparametergrenze):<\/p>\n
Klasse X< T erweitert List<? erweitert Number><\/span> <\/b> > {<\/tt>
\n \u00a0 public void someMethod(T t) {<\/tt>
\n \u00a0\u00a0\u00a0 t.add(new Long(0L));\u00a0\u00a0\u00a0 \/\/ Fehler<\/span> <\/b> <\/tt>
\n \u00a0\u00a0\u00a0 Zahl n = t.remove(0);<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt>
\n Klassentest {<\/tt>
\n \u00a0 public static void main(String[] args) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 <\/span> <\/b> X<ArrayList<<\/span> Lang<\/span> <\/b> >> x1 = new X<ArrayList<Long>>();\u00a0<\/span> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0 X<ArrayList<<\/span> Zeichenfolge<\/span> <\/b> >> x2 = new X<ArrayList<String>>(); <\/span> \/\/ Fehler<\/span> <\/b> <\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nReferenzvariablen vom Typ T <\/tt> (der Typparameter) werden wie Referenzvariablen eines Wildcard-Typs (der Typparameter gebunden) behandelt.\u00a0 In unserem Beispiel hat dies zur Folge, dass der Compiler den Aufruf von Methoden ablehnt, die ein Argument des \u201eunbekannten\u201c Typs annehmen, f\u00fcr den der Typparameter steht, wie z List.add<\/tt> , da es sich bei der Grenze um einen mit Platzhaltern parametrisierten Typ mit einer Obergrenze handelt.
\nGleichzeitig die Grenze List<? erweitert Number><\/tt> bestimmt die Typen, die als Typargumente verwendet werden k\u00f6nnen. Der Compiler akzeptiert alle Typargumente, die zur Typfamilie geh\u00f6ren List<? erweitert Number><\/tt> , also alle Untertypen von Liste<\/tt> mit einem Typargument, das ein Subtyp von ist Nummer<\/tt> .<\/p>\n
Ein Typparameter kann als Grenze eines anderen Typparameters verwendet werden.<\/p>\n
Beispiel (f\u00fcr einen Typparameter, der als Typparametergrenze verwendet wird):<\/p>\n
Klasse Triple <T><\/b> {<\/tt>
\n \u00a0 privates T fst, snd, trd;<\/tt>
\n \u00a0 \u00f6ffentlich < U<\/b> erweitert T<\/span> <\/b> , V erweitert T<\/span> <\/b> , W erweitert T<\/span> <\/b> > Triple(U arg1, V arg2, W arg3) {<\/tt>
\n \u00a0\u00a0\u00a0 fst = arg1;<\/tt>
\n \u00a0\u00a0\u00a0 snd = arg2;<\/tt>
\n \u00a0\u00a0\u00a0 trd = arg3;<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nIn diesem Beispiel der Typparameter T<\/tt> der parametrisierten Klasse wird als Grenze der Typparameter verwendet U<\/tt> ,\u00a0 V<\/tt> Und W<\/tt> einer parametrisierten Instanzmethode dieser Klasse.<\/p>\n
Weitere M\u00f6glichkeiten zur Verwendung von Typparametern als Grenzen anderer Typparameter umfassen Situationen, in denen ein verschachtelter Typ innerhalb eines generischen Typs oder eine lokale Klasse innerhalb einer generischen Methode definiert wird.\u00a0 Es ist sogar zul\u00e4ssig, einen Typparameter als Grenze eines anderen Typparameters im selben Typparameterabschnitt zu verwenden.<\/p>\n
Eine Grenze, die eine Klasse ist, gew\u00e4hrt Zugriff auf alle ihre \u00f6ffentlichen Mitglieder, also auf \u00f6ffentliche Felder, Methoden und verschachtelte Typen. Nur Konstruktoren werden nicht zug\u00e4nglich gemacht, da es keine Garantie daf\u00fcr gibt, dass eine Unterklasse der Bindung dieselben Konstruktoren wie die Bindung hat.<\/p>\n
Beispiel (einer Klasse, die als Grenze eines Typparameters verwendet wird):<\/p>\n
\u00f6ffentliche Klasse Superklasse<\/span> {<\/tt> \u00a0\u00a0\u00a0 \/\/ statische Mitglieder<\/tt>
\n \u00a0\u00a0\u00a0 \u00f6ffentliche Aufz\u00e4hlung EnumType {THIS, Those}<\/tt>
\n \u00a0\u00a0\u00a0 \u00f6ffentliches statisches Objekt staticField;<\/tt>
\n \u00a0\u00a0\u00a0 public static void staticMethod() { ... }<\/tt><\/p>\n \u00a0\u00a0\u00a0 \/\/ nicht statische Mitglieder<\/tt>
\n \u00a0\u00a0\u00a0 \u00f6ffentliche Klasse InnerClass { ... }<\/tt>
\n \u00a0\u00a0\u00a0 \u00f6ffentliches Objekt nonStaticField;<\/tt>
\n \u00a0\u00a0\u00a0 public void nonStaticMethod() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ Konstruktoren<\/tt>
\n \u00a0\u00a0\u00a0 public SuperClass() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ private Mitglieder<\/tt>
\n \u00a0\u00a0\u00a0 privates Objekt privateField;\u00a0<\/tt><\/p>\n
\u00a0\u00a0\u00a0 ...<\/tt>
\n }<\/tt><\/p>\n
\u00f6ffentliche Abschlussklasse SomeClass<T erweitert Superklasse<\/span> <\/b> > {<\/tt>
\n \u00a0\u00a0\u00a0 privates T-Objekt;<\/tt>
\n \u00a0\u00a0\u00a0 public SomeClass(T t) { object = t; }\u00a0<\/tt><\/p>\n \u00a0\u00a0\u00a0 \u00f6ffentlicher String toString() {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 zur\u00fcckkehren<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \u201estatischer verschachtelter Typ\u00a0\u00a0\u00a0 : \u201e+T.EnumType.class+\u201c\\n\u201c\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"statisches Feld\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+T.staticField+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"statische Methode\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+T.staticMethod()+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"nicht statischer verschachtelter Typ: \"+T.InnerClass.class+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"non-static field\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticField+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"nicht-statische Methode\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticMethod()+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"constructor\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+(new T())+\"\\n\"\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ Fehler<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"private member\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.privateField+\"\\n\"\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ Fehler\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Die Grenze Superklasse<\/tt> gew\u00e4hrt Zugriff auf seine verschachtelten Typen, statischen Felder und Methoden sowie nicht statische Felder und Methoden.\u00a0 Nur der Konstruktor ist nicht zug\u00e4nglich.\u00a0 Dies liegt daran, dass Konstruktoren nicht vererbt werden. Jede Unterklasse definiert ihre eigenen Konstruktoren und muss die Konstruktoren ihrer Oberklasse nicht unterst\u00fctzen.\u00a0 Daher gibt es keine Garantie daf\u00fcr, dass eine Unterklasse von Superklasse<\/tt> wird denselben Konstruktor wie seine Oberklasse haben.<\/p>\n
Der Kontext, in dem Enum<E erweitert Enum<E>><\/tt> ” erscheint, ist die Erkl\u00e4rung des Aufz\u00e4hlung<\/tt> Klasse im Paket java.lang<\/tt> :<\/p>\n \u00f6ffentliche abstrakte Klasse Enum<E erweitert Enum<E>><\/b> {<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Der Typ Aufz\u00e4hlung<\/tt> ist die gemeinsame Basisklasse aller Aufz\u00e4hlungstypen.\u00a0 In Java ein Aufz\u00e4hlungstyp wie Farbe<\/tt> wird in eine Klasse \u00fcbersetzt Farbe<\/tt> das erstreckt sich Enum<Color><\/tt> . Der Zweck der Superklasse Aufz\u00e4hlung<\/tt> besteht darin, Funktionen bereitzustellen, die allen Aufz\u00e4hlungstypen gemeinsam sind.<\/p>\n
Hier ist eine Skizze der Klasse Aufz\u00e4hlung<\/tt> :<\/p>\n \u00f6ffentliche abstrakte Klasse Enum< E<\/span> erweitert Enum<E>><\/b> implementiert Comparable< E<\/span> <\/b> >, Serialisierbar {<\/tt>
\n \u00a0 privater endg\u00fcltiger String-Name;<\/tt>
\n \u00a0 public final String name() { ... }<\/tt> \u00a0 private final int ordinal;<\/tt>
\n \u00a0 public final int ordinal() { ... }<\/tt><\/p>\n \u00a0 protected Enum(String name, int ordinal) { ... }<\/tt><\/p>\n
\u00a0 \u00f6ffentlicher String\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 toString() { ... }<\/tt>
\n \u00a0 public final boolean equals(Object other) { ... }<\/tt>
\n \u00a0 public final int hashCode() { ... }<\/tt>
\n \u00a0 protected final Object clone() l\u00f6st CloneNotSupportedException { ... } aus<\/tt>
\n \u00a0 public final int CompareTo( E<\/span> <\/b> o) { ... }<\/tt><\/p>\n \u00a0 \u00f6ffentliches Finale Class< E<\/span> <\/b> > getDeclaringClass() { ... }<\/tt>
\n \u00a0 public static <T erweitert Enum<T>> T valueOf(Class<T> enumType, String name) { ... }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nDas \u00dcberraschende in der Erkl\u00e4rung \u201e Enum<E erweitert Enum<E>><\/tt> ” ist die Tatsache, dass die neu definierte Klasse Aufz\u00e4hlung<\/tt> und sein neu definierter Typparameter E <\/tt> erscheinen in der Grenze desselben Typparameters.\u00a0 Es bedeutet, dass die Aufz\u00e4hlung<\/tt> Der Typ muss f\u00fcr einen seiner Untertypen instanziiert werden.\u00a0 Um zu verstehen, warum dies sinnvoll ist, bedenken Sie, dass jeder Aufz\u00e4hlungstyp in einen Untertyp von \u00fcbersetzt wird Aufz\u00e4hlung<\/tt> .<\/p>\n
Hier ist der erfundene Aufz\u00e4hlungstyp Farbe<\/tt> :<\/p>\n Aufz\u00e4hlung Farbe<\/b> {ROT, BLAU, GR\u00dcN}<\/tt><\/p><\/blockquote>\n
Der Compiler \u00fcbersetzt es in die folgende Klasse:<\/p>\n
\u00f6ffentliche Abschlussklasse Farbe<\/b> erstreckt sich Enum<Color><\/b> {<\/tt>
\n \u00a0 public static final Color[] Values() { return (Color[])$VALUES.clone(); }<\/tt>
\n \u00a0 \u00f6ffentlicher statischer FarbwertOf(String name) { ... }<\/tt> \u00a0 private Color(String s, int i) { super(s, i); }<\/tt><\/p>\n
\u00a0 \u00f6ffentliche statische endg\u00fcltige Farbe ROT;<\/tt>
\n \u00a0 \u00f6ffentliche statische endg\u00fcltige Farbe BLAU;<\/tt>
\n \u00a0 \u00f6ffentliche statische endg\u00fcltige Farbe GR\u00dcN;<\/tt><\/p>\n
\u00a0 private statische endg\u00fcltige Farbe $VALUES[];<\/tt><\/p>\n
\u00a0 statisch {<\/tt>
\n \u00a0\u00a0\u00a0 ROT = neue Farbe(\"RED\", 0);<\/tt>
\n \u00a0\u00a0\u00a0 BLAU = neue Farbe(\"BLAU\", 1);<\/tt>
\n \u00a0\u00a0\u00a0 GR\u00dcN = neue Farbe(\"GR\u00dcN\", 2);<\/tt>
\n \u00a0\u00a0\u00a0 $VALUES = (neue Farbe[] { ROT, BLAU, GR\u00dcN });<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Die Vererbung bewirkt, dass die Farbe<\/tt> Typ erbt alle in implementierten Methoden Enum<Color><\/tt> .\u00a0 Unter ihnen ist die vergleichenMit<\/tt> Verfahren.\u00a0 Der Farbe. vergleichenMit<\/tt> Methode sollte wahrscheinlich eine dauern Farbe<\/tt> als Argument.\u00a0 Um dies zu erm\u00f6glichen, Klasse Aufz\u00e4hlung<\/tt> ist generisch und die Enum.compareTo<\/tt> Methode dauert Aufz\u00e4hlung<\/tt> Typparameter E <\/tt> als Argument.\u00a0 Geben Sie als Ergebnis ein Farbe<\/tt> abgeleitet von Enum<Color><\/tt> erbt a vergleichenMit<\/tt> Methode, die eine dauert Farbe<\/tt> as und Argument, genau so, wie es sollte.
\nWenn wir die Erkl\u00e4rung analysieren: Enum<E erweitert Enum<E>><\/tt> \u201eWir k\u00f6nnen sehen, dass dieses Muster mehrere Aspekte hat.<\/p>\n
Erstens gibt es die Tatsache, dass der Typparameter, der gebunden wird, der Typ selbst ist: \u201e Aufz\u00e4hlung<\/b> <E erweitert Aufz\u00e4hlung<\/b> <E>><\/tt> “. Es stellt sicher, dass nur Untertypen des Typs vorhanden sind Aufz\u00e4hlung<\/tt> sind als Typargumente zul\u00e4ssig. (Theoretisch, Typ Aufz\u00e4hlung<\/tt> k\u00f6nnte auf sich selbst instanziiert werden, wie in Enum<Enum><\/tt> , aber das ist sicherlich nicht beabsichtigt und es ist schwer, sich eine Situation vorzustellen, in der eine solche Instanziierung n\u00fctzlich w\u00e4re.)<\/p>\n
Zweitens gibt es die Tatsache, dass der Parameter-gebundene Typ der parametrisierte Typ ist Aufz\u00e4hlung <E><\/b> <\/tt> , das den Typparameter verwendet E<\/tt> als Typargument der Grenze. Diese Deklaration stellt sicher, dass die Vererbungsbeziehung zwischen einem Subtyp und einer Instanziierung von Aufz\u00e4hlung<\/tt> ist von der Form X erweitert Enum<X><\/tt> “. Ein Untertyp wie \u201e X erweitert Enum<Y><\/tt> ” kann aufgrund des Typarguments nicht deklariert werden Y<\/tt> w\u00fcrde nicht innerhalb der Grenzen liegen; nur Unterarten von Enum<X><\/tt> liegen im Rahmen.<\/p>\n
Drittens gibt es die Tatsache, dass Aufz\u00e4hlung<\/tt> ist in erster Linie generisch.\u00a0 Dies bedeutet, dass einige Methoden der Klasse Aufz\u00e4hlung<\/tt> Nehmen Sie ein Argument an oder geben Sie einen Wert eines unbekannten Typs zur\u00fcck (oder h\u00e4ngen Sie auf andere Weise von einem unbekannten Typ ab). Wie wir bereits wissen, wird dieser unbekannte Typ sp\u00e4ter ein Untertyp sein X<\/tt> von Enum<X><\/tt> .\u00a0 Daher im parametrisierten Typ Enum<X><\/tt> , diese Methoden beinhalten den Untertyp X<\/tt> , und sie werden in den Untertyp vererbt X<\/tt> .\u00a0 Der vergleichenMit<\/tt> Methode ist ein Beispiel f\u00fcr eine solche Methode; Es wird von der Oberklasse in jede Unterklasse vererbt und verf\u00fcgt jeweils \u00fcber eine unterklassenspezifische Signatur.<\/p>\n
Um es zusammenzufassen: Die Erkl\u00e4rung \u201e Enum<E erweitert Enum<E>><\/tt> \u201ekann entziffert werden als: Aufz\u00e4hlung<\/tt> ist ein generischer Typ, der nur f\u00fcr seine Untertypen instanziiert werden kann, und diese Untertypen erben einige n\u00fctzliche Methoden, von denen einige untertypspezifische Argumente annehmen (oder auf andere Weise vom Untertyp abh\u00e4ngen).<\/p>\n
Typparameter der Untergrenze von Klassen<\/b><\/p>\n
Typparameter k\u00f6nnen mehrere Grenzen haben, wie in Klasse Box<T erweitert Number> {...}<\/tt> . Ein Typparameter kann jedoch keine untere Grenze haben, d. h. ein Konstrukt wie Klasse Box<T Gro\u00dfartig<\/b> Nummer> {...}<\/tt> ist nicht gestattet.\u00a0 Warum nicht?\u00a0 Die Antwort lautet: Es ist sinnlos, weil man damit nichts kaufen w\u00fcrde, wenn es erlaubt w\u00e4re.\u00a0 Lassen Sie uns sehen, warum die Untergrenze von Typparametern von Klassen verwirrend ist, indem wir untersuchen, was eine Obergrenze f\u00fcr einen Typparameter bedeutet.<\/p>\n
Die Obergrenze f\u00fcr einen Typparameter hat drei Auswirkungen:<\/p>\n
\n\n- Eingeschr\u00e4nkte Instanziierung.<\/i> <\/b> Die Obergrenze schr\u00e4nkt die Menge der Typen ein, die zur Instanziierung des generischen Typs verwendet werden k\u00f6nnen.\u00a0 Wenn wir a erkl\u00e4ren Klasse Box<T erweitert Number> {...} <\/tt> dann w\u00fcrde der Compiler sicherstellen, dass nur Untertypen von Nummer<\/tt> kann als Typargument verwendet werden.\u00a0 Das hei\u00dft, a Box<Number><\/tt> oder ein Box<Long><\/tt> ist erlaubt, aber a Box<Object><\/tt> oder Box<String><\/tt> w\u00fcrde abgelehnt werden<\/li>\n<\/ol>\n<\/ol>\n
Beispiel (f\u00fcr eine eingeschr\u00e4nkte Instanziierung aufgrund einer Obergrenze f\u00fcr einen Typparameter):
\n Klasse Box<T erweitert Number> {\u00a0<\/tt>
\n \u00a0\u00a0 privater T-Wert;\u00a0<\/tt>
\n \u00a0\u00a0 public Box(T t) { value = t; }\u00a0<\/tt>
\n \u00a0\u00a0 ...<\/tt>
\n }\u00a0<\/tt> Klassentest {\u00a0<\/tt>
\n \u00a0\u00a0 public static void main(String[] args) {\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<Long> boxOfLong = neue Box<Long>(0L);\u00a0\u00a0 \/\/ Bu\u00dfgeld<\/b> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<String> boxOfString = new Box<String>(\"\"); \/\/ Fehler: String liegt nicht innerhalb der Grenzen<\/span> <\/b> <\/tt>
\n \u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p>\n\n- Zugriff auf nicht-statische Mitglieder. <\/i> <\/b> Die Obergrenze erm\u00f6glicht den Zugriff auf alle \u00f6ffentlichen nicht statischen Methoden und Felder der Obergrenze.\u00a0 Bei der Umsetzung unserer Klasse Box<T erweitert Number> {...}<\/tt> Wir k\u00f6nnen alle in der Klasse definierten \u00f6ffentlichen nicht statischen Methoden aufrufen Nummer<\/tt> , wie zum Beispiel intValue()<\/tt> zum Beispiel.\u00a0 Ohne die Obergrenze w\u00fcrde der Compiler jeden solchen Aufruf ablehnen. Beispiel (f\u00fcr den Zugriff auf nicht statische Mitglieder aufgrund einer Obergrenze f\u00fcr einen Typparameter):<\/li>\n<\/ol>\n
Klasse Box<T erweitert Number> {\u00a0<\/tt>
\n \u00a0\u00a0 privater T-Wert;\u00a0<\/tt>
\n \u00a0\u00a0 public Box(T t) { value = t; }\u00a0<\/tt>
\n \u00a0\u00a0 public int increment() { return value.intValue()+1; } \/\/ <= w\u00e4re ein Fehler ohne die Zahl gebunden<\/b> <\/tt>
\n \u00a0\u00a0 ...<\/tt>