openbare leegte 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> limiet = nieuw Paar<String,Long><\/span> <\/b> (\"maximum\",1024L);<\/tt>
\n printPair(limiet);<\/tt><\/p><\/blockquote>\nVoorbeeld (van een met jokertekens geparametriseerd type):<\/p>\n
\n openbare leegte printPair( Paar<?,?><\/span> <\/b> paar) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Paar<?,?><\/span> <\/b> limiet = nieuw Paar<String,Long><\/span> <\/b> (\"maximum\",1024L);<\/tt>
\n printPair(limiet);<\/tt><\/p><\/blockquote>\n<\/blockquote>\nAlle instantiaties van een generiek type delen dezelfde runtime-typerepresentatie, namelijk de representatie van het onbewerkte type. Bijvoorbeeld de instantiaties van een generiek type Lijst<\/tt> , zoals Lijst<Datum><\/tt> , Lijst<String><\/tt> , Lijst<Lang><\/tt> , enz. hebben tijdens het compileren verschillende statische typen, maar hetzelfde dynamische type Lijst <\/tt> tijdens runtime.<\/p>\n
Een cast bestaat uit twee delen:<\/p>\n
\n- een statische typecontrole uitgevoerd door de compiler tijdens het compileren en<\/li>\n
- een dynamische typecontrole die tijdens runtime door de virtuele machine wordt uitgevoerd.<\/li>\n<\/ul>\n
Het statische deel sorteert onzinnige casts, die niet kunnen slagen, zoals de cast uit Snaar<\/tt> Dat Datum<\/tt> of van Lijst<String><\/tt> Dat Lijst<Datum><\/tt> .<\/p>\n
Het dynamische deel gebruikt de runtime-type-informatie en voert tijdens runtime een typecontrole uit.\u00a0 Het verhoogt een ClassCastException<\/tt> als het dynamische type van het object niet het doeltype (of een subtype van het doeltype) van de cast is. Voorbeelden van casts met een dynamische rol zijn de cast uit Voorwerp<\/tt> Dat Snaar<\/tt> of van Voorwerp<\/tt> Dat Lijst<String><\/tt> .\u00a0 Dit zijn de zogenaamde downcasts, van een supertype naar een subtype.<\/p>\n
Voorbeelden van concrete geparametriseerde typen zijn Lijst<String><\/tt> , Kaart<String, Datum><\/tt> , maar niet Lijst<? breidt Nummer> uit<\/tt> of Kaart<String,?><\/tt> .<\/p>\n
Soms wordt verwacht dat a Lijst<Object><\/tt> zou een supertype zijn van a Lijst<String><\/tt> , omdat Voorwerp<\/tt> is een supertype van Snaar<\/tt> .\u00a0 Deze verwachting komt voort uit het feit dat een dergelijk soort relatie bestaat voor arrays:\u00a0 Voorwerp[]<\/tt> is een supertype van Snaar[]<\/tt> , omdat Voorwerp<\/tt> is een supertype van Snaar<\/tt> . (Dit type relatie staat bekend als covariantie<\/i> .) De super-subtype-relatie van de componenttypen strekt zich uit tot de overeenkomstige arraytypen. Een dergelijke typerelatie bestaat niet voor instantiaties van generieke typen. (Geparametriseerde typen zijn niet<\/i> covariant.)<\/p>\n
Het ontbreken van een super-subtype-relatie tussen instantiaties van hetzelfde generieke type heeft verschillende gevolgen.\u00a0 Hier is een voorbeeld.<\/p>\n
Voorbeeld:<\/p>\n
void printAll(ArrayList<Object> c) {<\/tt>
\n \u00a0 voor (Object o: c)\u00a0<\/tt>
\n \u00a0\u00a0\u00a0 Systeem.out.println(o);<\/tt>
\n }<\/tt> ArrayList<String> lijst = nieuwe ArrayList<String>();<\/tt>
\n ... lijst invullen ...<\/tt>
\n printAll(lijst);\u00a0\u00a0 \/\/ fout<\/tt><\/p>\n
A ArrayLijst<String><\/tt> object kan niet als argument worden doorgegeven aan een methode die om a vraagt ArrayLijst<Object><\/tt> omdat de twee typen instantiaties zijn van hetzelfde generieke type, maar voor verschillend<\/i> type argumenten, en om deze reden zijn ze niet compatibel met elkaar.<\/p>\n
Concrete geparametriseerde typen zijn concrete instantiaties van een generiek type.\u00a0 Het lijken bijna typen; er zijn slechts een paar beperkingen.\u00a0 Ze kunnen NIET worden gebruikt voor de volgende doeleinden:<\/p>\n
\n- voor het maken van arrays<\/li>\n
- bij het afhandelen van uitzonderingen<\/li>\n
- in een klasse letterlijk<\/li>\n
- in een exemplaarvan<\/tt> uitdrukking<\/li>\n<\/ul>\n
Arrays die elementen bevatten waarvan het type een concreet geparameteriseerd type is, zijn illegaal.<\/p>\n
Voorbeeld (van illegaal arraytype):<\/p>\n
statische leegtetest() {<\/tt>
\n \u00a0 Paar<Geheel getal,Geheel getal>[]<\/span> <\/b> intPairArr = nieuw Paar<Geheel getal,Geheel getal>[10]<\/span> <\/b> ; \/\/ fout<\/span> <\/b> <\/tt>
\n \u00a0 addElements(intPairArr);\u00a0<\/tt>
\n \u00a0 Paar<Geheel getal,Geheel getal> paar = intPairArr[1];<\/tt>
\n \u00a0 Geheel getal i = paar.getFirst();<\/tt>
\n \u00a0 paar.setSecond(i);<\/tt>
\n }<\/tt>
\n statische leegte addElements( Voorwerp[]<\/b> objArr) {<\/tt>
\n \u00a0 objArr[0] = nieuw Paar<Geheel getal,Geheel getal>(0,0);<\/tt>
\n \u00a0 objArr[1] = nieuw Pair<String,String>(\"\",\"\");\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ zou moeten mislukken met ArrayStoreException<\/tt>
\n }<\/tt><\/p>\nDe compiler verbiedt het maken van arrays waarvan het componenttype een concreet geparametriseerd type is, zoals Paar<Geheel getal,Geheel getal><\/tt> in ons voorbeeld.\u00a0 We hebben in het voorgaande artikel besproken waarom het redelijk is dat de compiler een kwalificeert Paar<Geheel getal,Geheel getal>[]<\/tt> <\/span> als illegaal.\u00a0 Het belangrijkste probleem is dat de compiler en het runtimesysteem ervoor moeten zorgen dat een array een homogeen<\/i> reeks elementen van hetzelfde type.\u00a0 E\u00e9n van de typecontroles, namelijk de array-store-check die tijdens runtime door de virtuele machine wordt uitgevoerd, slaagt er niet in de inbreukmakende invoeging van een buitenaards element te detecteren. In het voorbeeld is de tweede invoeging in de elementen toevoegen<\/tt> methode zou moeten mislukken, omdat ze een paar strings aan een array van integrale waarden toevoegden, maar het mislukt niet zoals verwacht. De redenen zijn in het vorige bericht besproken.<\/p>\nAls we geen arrays kunnen gebruiken die elementen bevatten waarvan het type een concreet geparameteriseerd type is, wat gebruiken we dan als tijdelijke oplossing?<\/p>\n
Laten we drie mogelijke oplossingen bekijken:<\/p>\n
\n- reeks ruwe soorten<\/li>\n
- array van een onbegrensd, met jokertekens geparametriseerd type<\/li>\n
- verzameling in plaats van array<\/li>\n<\/ul>\n
Hoewel arrays van typen met concrete parameters illegaal zijn, zijn verzamelingen van typen met concrete parameters toegestaan.<\/p>\n
Een met jokertekens geparametriseerd type is een instantiatie van een generiek type waarbij ten minste \u00e9\u00e9n typeargument een jokerteken is.\u00a0 Voorbeelden van met jokertekens geparametriseerde typen zijn Collectie<?><\/tt> , Lijst<? breidt Nummer> uit<\/tt> , Vergelijker<? superString><\/tt> En Paar<String,?><\/tt> . Een met jokertekens geparametriseerd type duidt een familie van typen aan die concrete instantiaties van een generiek type omvat.\u00a0 Het soort jokerteken dat wordt gebruikt, bepaalt welke concrete geparametriseerde typen tot de familie behoren.\u00a0 Bijvoorbeeld het met jokertekens geparametriseerde type Collectie<?><\/tt> geeft de familie aan van alle instantiaties van de Verzameling<\/tt> interface, ongeacht het typeargument.\u00a0 Het met jokertekens geparametriseerde type Lijst<? breidt Nummer> uit<\/tt> geeft de familie van alle lijsttypen aan waarvan het elementtype een subtype is\u00a0 Nummer<\/tt> .\u00a0 Het met jokertekens geparametriseerde type Vergelijker<? superString><\/tt> is de familie van alle instantiaties van de Comparator<\/tt> interface voor type-argumenttypen die supertypes zijn van Snaar.<\/tt><\/p>\n
Een met jokertekens geparametriseerd type is geen type in de reguliere zin (anders dan een niet-geparametriseerde klasse\/interface of een onbewerkt type).<\/em> <\/strong><\/p>\nGeparametriseerde typen met jokertekens kunnen worden gebruikt voor typen (zoals niet-geparametriseerde klassen en interfaces):<\/p>\n
\n- als argument- en return-methoden<\/li>\n
- als type veld of lokale referentievariabele<\/li>\n
- als componenttype van een arrayas-typeargument van andere geparametriseerde typen<\/li>\n
- als doeltype bij afgietsels<\/li>\n<\/ul>\n
Niet alleen typen kunnen generiek zijn, maar methoden kunnen ook generiek zijn. Statische en niet-statische methoden, evenals constructors, kunnen typeparameters hebben. De syntaxis voor het declareren van de formele typeparameters is vergelijkbaar met de syntaxis voor generieke typen. De sectie voor typeparameters wordt begrensd door punthaken en verschijnt v\u00f3\u00f3r het retourtype van de methode. De syntaxis en betekenis ervan zijn identiek aan de typeparameterlijst van een generiek type.<\/p>\n
Hier is het voorbeeld van een generieke maximaal<\/tt> methode die de grootste waarde berekent in een verzameling elementen van een onbekend type A<\/tt> .<\/p>\n
Voorbeeld (van een generieke methode):<\/p>\n
klasse Collecties {<\/tt>
\n \u00a0 publiek statisch <A breidt Vergelijkbaar<A>> A uit<\/span> <\/b> max(Verzameling< 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.volgende();<\/tt>
\n \u00a0\u00a0\u00a0 terwijl (xi.hasNext()) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 A<\/span> <\/b> x = xi.volgende();<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 als (w.vergelijk(x) < 0) w = x;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0 retour w;<\/tt>
\n \u00a0 }<\/tt>
\n }\u00a0<\/tt><\/p><\/blockquote>\nDe maximaal<\/tt> methode heeft \u00e9\u00e9n typeparameter, genaamd A<\/tt> .\u00a0 Het is een tijdelijke aanduiding voor het elementtype van de verzameling waarop de methode werkt. De parameter type heeft een grens; het moet een type zijn dat een subtype is van Vergelijkbaar<A><\/tt><\/p>\n
Voorbeeld (van hetzelfde generieke type, deze keer met<\/i> grenzen):<\/p>\n openbare interface Vergelijkbaar<T> {<\/tt>
\n \u00a0 public int CompareTo(T arg);<\/tt>
\n }<\/tt>
\n openbare klasse TreeMap<Key breidt Vergelijkbare<Key> uit<\/span> <\/b> ,Gegevens>{<\/tt>
\n \u00a0 priv\u00e9 statische klasse Entry<K,V> {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 K-sleutel;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 V-waarde;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Invoer<K,V> links = nul;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Invoer<K,V> rechts = nul;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Vermelding<K,V> ouder;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 priv\u00e9 tijdelijke Entry<Key,Data> root = null;<\/tt>
\n \u00a0 ...<\/tt>
\n \u00a0 priv\u00e9-invoer<Key,Data> getEntry(sleutelsleutel) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Invoer<Sleutel,Gegevens> p = root;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Sleutel k = sleutel;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 terwijl (p!= nul) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 int cmp = k. vergelijkTo(p.key)<\/span> <\/b> ;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 als (cmp == 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 retour p;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 anders als (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 retourneer nul;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 public boolean containKey(Sleutelsleutel) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 return getEntry(sleutel) != null;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\nIn het bovenstaande voorbeeld is dit de parameter type Sleutel<\/tt> heeft de grens Vergelijkbaar<Sleutel><\/tt> .\u00a0 Het specificeren van een grens heeft twee effecten:<\/p>\n\n- Het geeft toegang tot de methoden die de grens specificeert<\/i> .\u00a0 In het voorbeeld de grens Vergelijkbaar<Sleutel> <\/tt> geeft toegang tot de vergelijkTo<\/tt> methode die we willen gebruiken bij de implementatie van onze Boomkaart<\/tt> klas.<\/li>\n<\/ul>\n
\n- Alleen typen “binnen de grenzen” kunnen worden gebruikt voor het instanti\u00ebren van het generieke type.<\/i> \u00a0 In het voorbeeld is een geparametriseerd type zoals Boomkaart<Number,String><\/tt> zou worden afgewezen, omdat het type Nummer<\/tt> is geen subtype van Vergelijkbaar<Nummer><\/tt> .\u00a0 Een geparametriseerd type zoals Boomkaart<String,String><\/tt> zou worden geaccepteerd, omdat het type String binnen de grenzen valt, d.w.z. een subtype is van Vergelijkbaar<String><\/tt> .<\/li>\n<\/ul>\n
Alle klassen, interfaces en enum-typen kunnen worden gebruikt als type-parametergebonden, inclusief geneste en innerlijke typen.\u00a0 Noch primitieve typen, noch arraytypen mogen worden gebruikt als typeparametergrens.<\/p>\n
Voorbeelden (van type parametergrenzen):<\/p>\n
klasse X0 <T breidt uit int<\/span> <\/b> > { ... }\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ fout<\/span> <\/b> <\/tt>
\n klasse X1 <T breidt zich uit Voorwerp[]<\/span> <\/b> > { ... } \/\/ fout<\/span> <\/b> <\/tt>
\n klasse X2 <T breidt zich uit Nummer<\/span> <\/b> > { ... }<\/tt>
\n klasse X3 <T breidt zich uit Snaar<\/span> <\/b> > { ... }<\/tt>
\n klasse X4 <T breidt uit Uitvoerbaar<\/span> <\/b> > { ... }<\/tt>
\n klasse X5 <T breidt zich uit Draad.State<\/span> <\/b> > { ... }<\/tt>
\n klasse X6 <T breidt zich uit Lijst<\/span> <\/b> > { ... }<\/tt>
\n klasse X7 <T breidt zich uit Lijst<String><\/span> <\/b> > { ... }<\/tt>
\n klasse X8 <T breidt zich uit Lijst<? breidt Nummer> uit<\/span> <\/b> > { ... }<\/tt>
\n klasse X9 <T breidt zich uit Vergelijkbaar<? supernummer><\/span> <\/b> > { ... }<\/tt>
\n klasse X10<T breidt zich uit Kaart.Invoer<?,?><\/span> <\/b> > { ... }<\/tt><\/p><\/blockquote>\nHet codevoorbeeld laat zien dat primitieve typen zoals int<\/tt> en arraytypen zoals Voorwerp[] <\/tt> zijn niet toegestaan \u200b\u200bals typeparametergebonden.<\/p>\n
Klassetypen, zoals Nummer<\/tt> of Snaar<\/tt> en interfacetypen, zoals Uitvoerbaar<\/tt> , zijn toegestaan \u200b\u200bals typeparametergebonden.<\/p>\n
Enum-typen, zoals Draad.State<\/tt> zijn ook toegestaan \u200b\u200bals typeparametergebonden. Draad.State<\/tt> is een voorbeeld van een genest type dat wordt gebruikt als typeparametergebonden.\u00a0 Ook niet-statische binnenuitvoeringen zijn toegestaan.<\/p>\n
Ruwe typen zijn toegestaan \u200b\u200bals typeparametergebonden; Lijst<\/span> <\/tt> is een voorbeeld.<\/p>\nGeparametriseerde typen zijn toegestaan \u200b\u200bals typeparametergebonden, inclusief concrete geparametriseerde typen zoals Lijst<String><\/tt> , begrensde typen met jokertekens, zoals Lijst<? breidt Nummer> uit<\/tt> En Vergelijkbaar<? superLong><\/tt> en onbegrensde typen met jokertekens, zoals Kaart.Invoer<?,?><\/tt> .\u00a0 Een grens die een met jokertekens geparametriseerd type is, staat als typeargument alle typen toe die behoren tot de typefamilie die door het jokerteken wordt aangegeven.\u00a0 De met jokertekens geparametriseerde typegrens geeft slechts beperkte toegang tot velden en methoden; de beperkingen zijn afhankelijk van het soort wildcard.<\/p>\n
Voorbeeld (van met jokertekens geparametriseerd type als type parameter gebonden):<\/p>\n
klasse X< T breidt Lijst< uit? breidt Nummer> uit<\/span> <\/b> > {<\/tt>
\n \u00a0 public void someMethod(T t) {<\/tt>
\n \u00a0\u00a0\u00a0 t.add(nieuw lang(0L));\u00a0\u00a0\u00a0 \/\/ fout<\/span> <\/b> <\/tt>
\n \u00a0\u00a0\u00a0 Getal n = t.verwijder(0);<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt>
\n klasse Test {<\/tt>
\n \u00a0 public static void main(String[] args) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 <\/span> <\/b> X<ArrayLijst<<\/span> Lang<\/span> <\/b> >> x1 = nieuwe X<ArrayList<Long>>();\u00a0<\/span> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0 X<ArrayLijst<<\/span> Snaar<\/span> <\/b> >> x2 = nieuwe X<ArrayList<String>>(); <\/span> \/\/ fout<\/span> <\/b> <\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nReferentievariabelen van het type T <\/tt> (de typeparameter) worden behandeld als referentievariabelen van het jokertekentype (de typeparameter gebonden).\u00a0 In ons voorbeeld is de consequentie dat de compiler het aanroepen van methoden afwijst die een argument aannemen van het “onbekende” type waarvoor de parameter type staat, zoals Lijst.toevoegen<\/tt> , omdat de grens een met jokertekens geparametriseerd type is met een bovengrens.
\nTegelijkertijd de grens Lijst<? breidt Nummer> uit<\/tt> bepaalt de typen die kunnen worden gebruikt als typeargumenten. De compiler accepteert alle typeargumenten die tot de typefamilie behoren Lijst<? breidt Nummer> uit<\/tt> , dat wil zeggen, alle subtypen van Lijst<\/tt> met een type-argument dat een subtype is van Nummer<\/tt> .<\/p>\n
Een typeparameter kan worden gebruikt als grens voor een andere typeparameter.<\/p>\n
Voorbeeld (van een typeparameter die wordt gebruikt als een typeparametergebonden):<\/p>\n
klasse Drievoudig <T><\/b> {<\/tt>
\n \u00a0 priv\u00e9 T fst, snd, trd;<\/tt>
\n \u00a0 openbare < U<\/b> verlengt T<\/span> <\/b> , V verlengt T<\/span> <\/b> , W verlengt T<\/span> <\/b> > Drievoudig(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 dit voorbeeld de parameter type T<\/tt> van de geparametriseerde klasse wordt gebruikt als grens van de typeparameters U<\/tt> ,\u00a0 V<\/tt> En W<\/tt> van een geparametriseerde instantiemethode van die klasse.<\/p>\n
Verdere mogelijkheden voor het gebruik van typeparameters als grenzen van andere typeparameters zijn onder meer situaties waarin een genest type is gedefinieerd binnen een generiek type of een lokale klasse is gedefinieerd binnen een generieke methode.\u00a0 Het is zelfs toegestaan \u200b\u200bom een \u200b\u200btypeparameter te gebruiken als grens van een andere typeparameter in dezelfde typeparametersectie.<\/p>\n
Een grens die een klasse is, geeft toegang tot al zijn openbare leden, dat wil zeggen openbare velden, methoden en geneste typen. Alleen constructors worden niet toegankelijk gemaakt, omdat er geen garantie is dat een subklasse van de bound dezelfde constructors heeft als de bound.<\/p>\n
Voorbeeld (van een klasse die wordt gebruikt als grens van een typeparameter):<\/p>\n
openbare klasse SuperKlasse<\/span> {<\/tt> \u00a0\u00a0\u00a0 \/\/ statische leden<\/tt>
\n \u00a0\u00a0\u00a0 openbare opsomming EnumType {DIT, DAT}<\/tt>
\n \u00a0\u00a0\u00a0 publiek statisch Object staticField;<\/tt>
\n \u00a0\u00a0\u00a0 openbare statische leegte staticMethod() { ... }<\/tt><\/p>\n \u00a0\u00a0\u00a0 \/\/ niet-statische leden<\/tt>
\n \u00a0\u00a0\u00a0 openbare klasse InnerClass { ... }<\/tt>
\n \u00a0\u00a0\u00a0 openbaar object nonStaticField;<\/tt>
\n \u00a0\u00a0\u00a0 public void nonStaticMethod() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ constructeurs<\/tt>
\n \u00a0\u00a0\u00a0 openbare SuperKlasse() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ priv\u00e9 leden<\/tt>
\n \u00a0\u00a0\u00a0 priv\u00e9-object privateField;\u00a0<\/tt><\/p>\n
\u00a0\u00a0\u00a0 ...<\/tt>
\n }<\/tt><\/p>\n
openbare eindklasse SomeClass<T breidt zich uit SuperKlasse<\/span> <\/b> > {<\/tt>
\n \u00a0\u00a0\u00a0 priv\u00e9 T-object;<\/tt>
\n \u00a0\u00a0\u00a0 publiek SomeClass(T t) {object = t; }\u00a0<\/tt><\/p>\n \u00a0\u00a0\u00a0 openbare tekenreeks toString() {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 opbrengst<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \"statisch genest type\u00a0\u00a0\u00a0: \"+T.EnumType.class+\"\\n\"\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"statisch veld\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 +\"niet-statisch genest type: \"+T.InnerClass.class+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"niet-statisch veld\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticField+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"niet-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 : \"+(nieuwe T())+\"\\n\"\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ fout<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"priv\u00e9lid\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.privateField+\"\\n\"\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ fout\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
De grens SuperKlasse<\/tt> geeft toegang tot de geneste typen, statische velden en methoden en niet-statische velden en methoden.\u00a0 Alleen de constructor is niet toegankelijk.\u00a0 Dit komt omdat constructors niet worden ge\u00ebrfd. Elke subklasse definieert zijn eigen constructors en hoeft de constructors van zijn superklasse niet te ondersteunen.\u00a0 Er is dus geen garantie dat een subklasse van SuperKlasse<\/tt> zal dezelfde constructor hebben als zijn superklasse.<\/p>\n
De context waarin Enum<E breidt Enum<E>> uit<\/tt> ” verschijnt is de verklaring van de Enum<\/tt> klasse in pakket java.lang<\/tt> :<\/p>\n openbare abstracte klasse Enum<E breidt Enum<E>> uit<\/b> {<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Het soort Enum<\/tt> is de gemeenschappelijke basisklasse van alle opsommingstypen.\u00a0 In Java is een opsommingstype zoals Kleur<\/tt> wordt vertaald naar een klasse Kleur<\/tt> dat strekt zich uit Enum<Kleur><\/tt> . Het doel van de superklasse Enum<\/tt> is om functionaliteit te bieden die gemeenschappelijk is voor alle opsommingstypen.<\/p>\n
Hier is een schets van klasse Enum<\/tt> :<\/p>\n openbare abstracte klasse Enum< E<\/span> breidt Enum<E>> uit<\/b> implementeert Vergelijkbaar< E<\/span> <\/b> >, serialiseerbaar {<\/tt>
\n \u00a0 priv\u00e9 uiteindelijke tekenreeksnaam;<\/tt>
\n \u00a0 openbare finale Stringnaam() { ... }<\/tt> \u00a0 priv\u00e9 finale int rangtelwoord;<\/tt>
\n \u00a0 publieke finale int ordinal() { ... }<\/tt><\/p>\n \u00a0 protected Enum(Stringnaam, int rangtelwoord) { ... }<\/tt><\/p>\n
\u00a0 public String\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 toString() { ... }<\/tt>
\n \u00a0 public final boolean is gelijk aan (Object anders) { ... }<\/tt>
\n \u00a0 openbare finale int hashCode() { ... }<\/tt>
\n \u00a0 beschermde uiteindelijke Objectkloon() gooit CloneNotSupportedException { ... }<\/tt>
\n \u00a0 openbare finale int CompareTo( E<\/span> <\/b> o) { ... }<\/tt><\/p>\n \u00a0 openbare finale Class< E<\/span> <\/b> > getDeclaringClass() { ... }<\/tt>
\n \u00a0 openbare statische <T breidt Enum<T>> T waardeOf(Class<T> enumType, String naam) { ... }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nHet verrassende kenmerk in de verklaring “ Enum<E breidt Enum<E>> uit<\/tt> ” is het feit dat de nieuw gedefinieerde klasse Enum<\/tt> en de nieuw gedefinieerde typeparameter E <\/tt> verschijnen binnen de grens van dezelfde typeparameter.\u00a0 Het betekent dat de Enum<\/tt> type moet worden ge\u00efnstantieerd voor een van zijn subtypen.\u00a0 Om te begrijpen waarom dit logisch is, moet je bedenken dat elk enum-type wordt vertaald in een subtype van Enum<\/tt> .<\/p>\n
Hier is het gekunstelde enum-type Kleur<\/tt> :<\/p>\n opsomming Kleur<\/b> {ROOD, BLAUW, GROEN}<\/tt><\/p><\/blockquote>\n
De compiler vertaalt het naar de volgende klasse:<\/p>\n
openbare eindklasse Kleur<\/b> strekt zich uit Enum<Kleur><\/b> {<\/tt>
\n \u00a0 openbare statische definitieve kleur[]-waarden() { return (kleur[])$VALUES.clone(); }<\/tt>
\n \u00a0 public static KleurwaardeOf(Stringnaam) { ... }<\/tt> \u00a0 priv\u00e9 Kleur(String s, int i) { super(s, i); }<\/tt><\/p>\n
\u00a0 openbare statische finale Kleur ROOD;<\/tt>
\n \u00a0 openbare statische finale Kleur BLAUW;<\/tt>
\n \u00a0 openbare statische finale Kleur GROEN;<\/tt><\/p>\n
\u00a0 priv\u00e9 statische uiteindelijke kleur $VALUES[];<\/tt><\/p>\n
\u00a0 statisch {<\/tt>
\n \u00a0\u00a0\u00a0 ROOD = nieuwe kleur(\"ROOD\", 0);<\/tt>
\n \u00a0\u00a0\u00a0 BLAUW = nieuwe kleur(\"BLAUW\", 1);<\/tt>
\n \u00a0\u00a0\u00a0 GROEN = nieuwe kleur(\"GROEN\", 2);<\/tt>
\n \u00a0\u00a0\u00a0 $VALUES = (nieuwe kleur[] { ROOD, BLAUW, GROEN });<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
De erfenis heeft tot gevolg dat de Kleur<\/tt> type erft alle methoden die erin zijn ge\u00efmplementeerd Enum<Kleur><\/tt> .\u00a0 Onder hen bevindt zich de vergelijkTo<\/tt> methode.\u00a0 De Kleur. vergelijkTo<\/tt> methode zou waarschijnlijk a moeten nemen Kleur<\/tt> als argument.\u00a0 Om dit mogelijk te maken, klasse Enum<\/tt> is generiek en de Enum.vergelijkTo<\/tt> methode duurt Enum<\/tt> ‘s typeparameter E <\/tt> als argument.\u00a0 Als resultaat typt u Kleur<\/tt> afgeleid van Enum<Kleur><\/tt> erft een vergelijkTo<\/tt> methode die een Kleur<\/tt> zoals en argument, precies zoals het hoort.
\nAls we de verklaring ontleden “ Enum<E breidt Enum<E>> uit<\/tt> ” we kunnen zien dat dit patroon verschillende aspecten heeft.<\/p>\n
Ten eerste is er het feit dat de parameter type gebonden het type zelf is: “ Enum<\/b> <E breidt uit Enum<\/b> <E>><\/tt> “. Het zorgt ervoor dat alleen subtypen van type zijn Enum<\/tt> zijn toegestaan \u200b\u200bals typeargumenten. (Theoretisch, typ Enum<\/tt> zou op zichzelf kunnen worden ge\u00efnstantieerd, zoals in Enum<ENum><\/tt> , maar dit is zeker niet de bedoeling en het is moeilijk een situatie voor te stellen waarin een dergelijke instantiatie nuttig zou zijn.)<\/p>\n
Ten tweede is er het feit dat het parametergebonden type het geparametriseerde type is Enum <E><\/b> <\/tt> , die de parameter type gebruikt E<\/tt> als het typeargument van de grens. Deze declaratie zorgt ervoor dat de overervingsrelatie tussen een subtype en een instantiatie van Enum<\/tt> is van de vorm X breidt Enum<X> uit<\/tt> “. Een subtype zoals “ X breidt Enum<Y> uit<\/tt> ” kan niet worden gedeclareerd vanwege het argument type Y<\/tt> zou niet binnen de perken blijven; alleen subtypes van Enum<X><\/tt> zijn binnen de perken.<\/p>\n
In de derde plaats is er het feit dat Enum<\/tt> is in de eerste plaats generiek.\u00a0 Het betekent dat sommige van de methoden van klasse Enum<\/tt> neem een \u200b\u200bargument of retourneer een waarde van een onbekend type (of afhankelijk van een onbekend type). Zoals we al weten, zal dit onbekende type later een subtype zijn X<\/tt> van Enum<X><\/tt> .\u00a0 Daarom in het geparametriseerde type Enum<X><\/tt> Bij deze methoden is het subtype betrokken X<\/tt> , en ze worden overgenomen in het subtype X<\/tt> .\u00a0 De vergelijkTo<\/tt> methode is een voorbeeld van een dergelijke methode; het wordt ge\u00ebrfd van de superklasse in elke subklasse en heeft in elk geval een subklasse-specifieke handtekening.<\/p>\n
Kortom, de verklaring “ Enum<E breidt Enum<E>> uit<\/tt> ” kan worden ontcijferd als: Enum<\/tt> is een generiek type dat alleen kan worden ge\u00efnstantieerd voor zijn subtypen, en die subtypen zullen een aantal nuttige methoden erven, waarvan sommige subtype-specifieke argumenten gebruiken (of anderszins afhankelijk zijn van het subtype).<\/p>\n
Ondergrenstypeparameters van klassen<\/b><\/p>\n
Typeparameters kunnen verschillende grenzen hebben, zoals in klasse Box<T breidt Nummer> uit {...}<\/tt> . Maar een typeparameter kan geen ondergrens hebben, dat wil zeggen een constructie zoals klasse Box<T Geweldig<\/b> Nummer> {...}<\/tt> is niet toegestaan.\u00a0 Waarom niet?\u00a0 Het antwoord is: het heeft geen zin, want als het toegestaan \u200b\u200bwas, zou je er niets mee kopen.\u00a0 Laten we eens kijken waarom ondergrenstypeparameters van klassen verwarrend zijn door te onderzoeken wat een bovengrens voor een typeparameter betekent.<\/p>\n
De bovengrens voor een typeparameter heeft drie effecten:<\/p>\n
\n\n- Beperkte instantiatie.<\/i> <\/b> De bovengrens beperkt de set typen die kunnen worden gebruikt voor het instanti\u00ebren van het generieke type.\u00a0 Als we verklaren a klasse Box<T breidt Nummer> uit {...} <\/tt> dan zou de compiler ervoor zorgen dat alleen subtypen van Nummer<\/tt> kan worden gebruikt als typeargument.\u00a0 Dat wil zeggen, een Doos<Nummer><\/tt> of een Doos<Lang><\/tt> is toegestaan, maar a Vak<Object><\/tt> of Vak<String><\/tt> zou worden afgewezen<\/li>\n<\/ol>\n<\/ol>\n
Voorbeeld (van beperkte instantiatie vanwege een bovengrens voor een typeparameter):
\n klasse Box<T breidt Nummer> uit {\u00a0<\/tt>
\n \u00a0\u00a0 priv\u00e9 T-waarde;\u00a0<\/tt>
\n \u00a0\u00a0 openbare Box(T t) { waarde = t; }\u00a0<\/tt>
\n \u00a0\u00a0 ...<\/tt>
\n }\u00a0<\/tt> klasse Test {\u00a0<\/tt>
\n \u00a0\u00a0 public static void main(String[] args) {\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<Long> boxOfLong = nieuwe Box<Long>(0L);\u00a0\u00a0 \/\/ prima<\/b> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<String> boxOfString = nieuwe Box<String>(\"\"); \/\/ fout: String ligt niet binnen de grenzen<\/span> <\/b> <\/tt>
\n \u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p>\n\n- Toegang tot niet-statische leden. <\/i> <\/b> De bovengrens geeft toegang tot alle openbare niet-statische methoden en velden van de bovengrens.\u00a0 Bij de uitvoering van onze klasse Box<T breidt Nummer> uit {...}<\/tt> we kunnen alle openbare niet-statische methoden aanroepen die in de klasse zijn gedefinieerd Nummer<\/tt> , zoals intWaarde()<\/tt> bijvoorbeeld.\u00a0 Zonder de bovengrens zou de compiler een dergelijke aanroep afwijzen. Voorbeeld (van toegang tot niet-statische leden vanwege een bovengrens voor een typeparameter):<\/li>\n<\/ol>\n
klasse Box<T breidt Nummer> uit {\u00a0<\/tt>
\n \u00a0\u00a0 priv\u00e9 T-waarde;\u00a0<\/tt>
\n \u00a0\u00a0 openbare Box(T t) { waarde = t; }\u00a0<\/tt>
\n \u00a0\u00a0 public int increment() {retourwaarde.intValue()+1; } \/\/ <= zou een fout zijn zonder de nummergrens<\/b> <\/tt>
\n \u00a0\u00a0 ...<\/tt>