publiczna niewa\u017cna printPair( Para<String,Long><\/span> <\/b> para) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Para<String,Long><\/span> <\/b> limit = nowy Para<String,Long><\/span> <\/b> (\u201emaksimum\u201d, 1024L);<\/tt>
\n printPair(limit);<\/tt><\/p><\/blockquote>\nPrzyk\u0142ad (typu sparametryzowanego za pomoc\u0105 symboli wieloznacznych):<\/p>\n
\n publiczna niewa\u017cna printPair( Para<?,?><\/span> <\/b> para) {<\/tt>
\n \u00a0 System.out.println(\"(\"+pair.getFirst()+\",\"+pair.getSecond()+\")\");<\/tt>
\n }<\/tt> Para<?,?><\/span> <\/b> limit = nowy Para<String,Long><\/span> <\/b> (\u201emaksimum\u201d, 1024L);<\/tt>
\n printPair(limit);<\/tt><\/p><\/blockquote>\n<\/blockquote>\nWszystkie wyst\u0105pienia typu og\u00f3lnego maj\u0105 t\u0119 sam\u0105 reprezentacj\u0119 typu \u015brodowiska wykonawczego, a mianowicie reprezentacj\u0119 typu surowego. Na przyk\u0142ad instancje typu og\u00f3lnego Lista<\/tt> , takie jak Lista<Data><\/tt> , Lista<String><\/tt> , Lista<D\u0142ugi><\/tt> itp. maj\u0105 r\u00f3\u017cne typy statyczne w czasie kompilacji, ale ten sam typ dynamiczny Lista <\/tt> w czasie wykonywania.<\/p>\n
Obsada sk\u0142ada si\u0119 z dw\u00f3ch cz\u0119\u015bci:<\/p>\n
\n- statyczna kontrola typu wykonywana przez kompilator w czasie kompilacji i<\/li>\n
- dynamiczna kontrola typu wykonywana przez maszyn\u0119 wirtualn\u0105 w czasie wykonywania.<\/li>\n<\/ul>\n
Cz\u0119\u015b\u0107 statyczna sortuje bezsensowne rzuty, kt\u00f3re nie mog\u0105 si\u0119 powie\u015b\u0107, takie jak rzutowanie z Smyczkowy<\/tt> To Data<\/tt> lub z Lista<String><\/tt> To Lista<Data><\/tt> .<\/p>\n
Cz\u0119\u015b\u0107 dynamiczna wykorzystuje informacje o typie \u015brodowiska wykonawczego i przeprowadza kontrol\u0119 typu w czasie wykonywania.\u00a0 Podnosi A Wyj\u0105tek ClassCast<\/tt> je\u015bli typ dynamiczny obiektu nie jest typem docelowym (lub podtypem typu docelowego) rzutowania. Przyk\u0142adami odlew\u00f3w z cz\u0119\u015bci\u0105 dynamiczn\u0105 s\u0105 odlewy Obiekt<\/tt> To Smyczkowy<\/tt> lub z Obiekt<\/tt> To Lista<String><\/tt> .\u00a0 S\u0105 to tak zwane downcasty, od nadtypu do podtypu.<\/p>\n
Przyk\u0142adami konkretnych typ\u00f3w sparametryzowanych s\u0105 Lista<String><\/tt> , Mapa<String,Data><\/tt> , ale nie Lista<? rozszerza numer ><\/tt> Lub Mapa<String,?><\/tt> .<\/p>\n
Czasami oczekuje si\u0119, \u017ce a Lista<Object><\/tt> by\u0142by nadtypem a Lista<String><\/tt> , poniewa\u017c Obiekt<\/tt> jest nadtypem Smyczkowy<\/tt> .\u00a0 Oczekiwanie to wynika z faktu, \u017ce dla tablic istnieje tego typu zale\u017cno\u015b\u0107:\u00a0 Obiekt[]<\/tt> jest nadtypem Smyczkowy[]<\/tt> , poniewa\u017c Obiekt<\/tt> jest nadtypem Smyczkowy<\/tt> . (Ten typ relacji jest znany jako kowariancja<\/i> .) Relacja superpodtyp\u00f3w typ\u00f3w komponent\u00f3w rozci\u0105ga si\u0119 na odpowiednie typy tablic. Nie istnieje taka relacja typu dla instancji typ\u00f3w og\u00f3lnych. (Typy sparametryzowane to nie<\/i> kowariant.)<\/p>\n
Brak relacji superpodtypu mi\u0119dzy instancjami tego samego typu og\u00f3lnego ma r\u00f3\u017cne konsekwencje.\u00a0 Oto przyk\u0142ad.<\/p>\n
Przyk\u0142ad:<\/p>\n
void printAll(ArrayList<Object> c) {<\/tt>
\n \u00a0 dla (Obiekt o : c)\u00a0<\/tt>
\n \u00a0\u00a0\u00a0 System.out.println(o);<\/tt>
\n }<\/tt> Lista ArrayList<String> = nowa lista ArrayList<String>();<\/tt>
\n ... wype\u0142nij list\u0119 ...<\/tt>
\n printAll(lista);\u00a0\u00a0 \/\/ b\u0142\u0105d<\/tt><\/p>\n
A ArrayList<String><\/tt> obiektu nie mo\u017cna przekaza\u0107 jako argumentu do metody \u017c\u0105daj\u0105cej a ArrayList<Object><\/tt> poniewa\u017c te dwa typy s\u0105 instancjami tego samego typu og\u00f3lnego, ale for r\u00f3\u017cny<\/i> argumenty typu i z tego powodu nie s\u0105 one ze sob\u0105 kompatybilne.<\/p>\n
Konkretne typy sparametryzowane to konkretne instancje typu og\u00f3lnego.\u00a0 S\u0105 prawie jak typy; istnieje tylko kilka ogranicze\u0144.\u00a0 NIE mo\u017cna ich u\u017cywa\u0107 do nast\u0119puj\u0105cych cel\u00f3w:<\/p>\n
\n- do tworzenia tablic<\/li>\n
- w obs\u0142udze wyj\u0105tk\u00f3w<\/li>\n
- w dos\u0142owno\u015bci klasowej<\/li>\n
- w instancja<\/tt> wyra\u017cenie<\/li>\n<\/ul>\n
Tablice zawieraj\u0105ce elementy, kt\u00f3rych typ jest konkretnym typem sparametryzowanym, s\u0105 nielegalne.<\/p>\n
Przyk\u0142ad (niedozwolony typ tablicy):<\/p>\n
statyczny test niewa\u017cno\u015bci() {<\/tt>
\n \u00a0 Para<Integer,Integer>[]<\/span> <\/b> intPairArr = nowy Para<Integer,Integer>[10]<\/span> <\/b> ; \/\/ b\u0142\u0105d<\/span> <\/b> <\/tt>
\n \u00a0 addElements(intPairArr);\u00a0<\/tt>
\n \u00a0 Para<Integer,Integer> para = intPairArr[1];<\/tt>
\n \u00a0 Liczba ca\u0142kowita i = pair.getFirst();<\/tt>
\n \u00a0 para.setSekunda(i);<\/tt>
\n }<\/tt>
\n statyczne puste elementy addElements( Obiekt[]<\/b> objArr) {<\/tt>
\n \u00a0 objArr[0] = nowa para<Integer,Integer>(0,0);<\/tt>
\n \u00a0 objArr[1] = nowa para<String,String>(\"\",\"\");\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ powinno zako\u0144czy\u0107 si\u0119 niepowodzeniem z wyj\u0105tkiem ArrayStoreException<\/tt>
\n }<\/tt><\/p>\nKompilator zabrania tworzenia tablic, kt\u00f3rych typem komponentu jest konkretny typ sparametryzowany, np Para<Integer,Integer><\/tt> w naszym przyk\u0142adzie.\u00a0 W poprzednim wpisie om\u00f3wili\u015bmy, dlaczego uzasadnione jest, aby kompilator kwalifikowa\u0142 a Para<Integer,Integer>[]<\/tt> <\/span> jako nielegalne.\u00a0 Kluczowym problemem jest to, \u017ce kompilator i system wykonawczy musz\u0105 zapewni\u0107, \u017ce tablica jest tablic\u0105 typu a jednorodny<\/i> sekwencja element\u00f3w tego samego typu.\u00a0 Jedna ze kontroli typu, a mianowicie kontrola magazynu tablic wykonywana przez maszyn\u0119 wirtualn\u0105 w czasie wykonywania, nie wykrywa nieprawid\u0142owego wstawienia obcego elementu. W przyk\u0142adzie drugie wstawienie w dodaj elementy<\/tt> metoda powinna zako\u0144czy\u0107 si\u0119 niepowodzeniem, poniewa\u017c dodawana by\u0142a para ci\u0105g\u00f3w do tablicy warto\u015bci ca\u0142kowitych, ale nie zako\u0144czy\u0142a si\u0119 niepowodzeniem zgodnie z oczekiwaniami. Powody zosta\u0142y om\u00f3wione w poprzednim wpisie.<\/p>\nJe\u015bli nie mo\u017cemy u\u017cywa\u0107 tablic przechowuj\u0105cych elementy, kt\u00f3rych typ jest konkretnym typem sparametryzowanym, czego u\u017cywamy jako obej\u015bcia?<\/p>\n
Rozwa\u017cmy 3 mo\u017cliwe obej\u015bcia:<\/p>\n
\n- szereg surowych typ\u00f3w<\/li>\n
- tablica nieograniczonego typu parametrycznego z symbolami wieloznacznymi<\/li>\n
- kolekcja zamiast tablicy<\/li>\n<\/ul>\n
Chocia\u017c tablice konkretnych typ\u00f3w sparametryzowanych s\u0105 nielegalne, kolekcje konkretnych typ\u00f3w sparametryzowanych s\u0105 dozwolone.<\/p>\n
Typ sparametryzowany za pomoc\u0105 symboli wieloznacznych jest instancj\u0105 typu og\u00f3lnego, w kt\u00f3rym co najmniej jeden argument typu jest symbolem wieloznacznym.\u00a0 Przyk\u0142adami typ\u00f3w sparametryzowanych za pomoc\u0105 symboli wieloznacznych s\u0105 Kolekcja<?><\/tt> , Lista<? rozszerza numer ><\/tt> , Komparator<? super String><\/tt> I Para<String,?><\/tt> . Typ sparametryzowany za pomoc\u0105 symbolu wieloznacznego oznacza rodzin\u0119 typ\u00f3w zawieraj\u0105c\u0105 konkretne instancje typu og\u00f3lnego.\u00a0 Rodzaj u\u017cytego symbolu wieloznacznego okre\u015bla, kt\u00f3re konkretne sparametryzowane typy nale\u017c\u0105 do rodziny.\u00a0 Na przyk\u0142ad typ sparametryzowany symbolem wieloznacznym Kolekcja<?><\/tt> oznacza rodzin\u0119 wszystkich instancji Kolekcja<\/tt> interfejs niezale\u017cnie od argumentu typu.\u00a0 Typ sparametryzowany symbolem wieloznacznym Lista<? rozszerza numer ><\/tt> oznacza rodzin\u0119 wszystkich typ\u00f3w list, kt\u00f3rych typ elementu jest podtypem\u00a0 Numer<\/tt> .\u00a0 Typ sparametryzowany symbolem wieloznacznym Komparator<? super String><\/tt> jest rodzin\u0105 wszystkich instancji Komparator<\/tt> interfejs dla typ\u00f3w argument\u00f3w typu, kt\u00f3re s\u0105 nadtypami Smyczkowy.<\/tt><\/p>\n
Typ sparametryzowany za pomoc\u0105 symboli wieloznacznych nie jest typem w zwyk\u0142ym sensie (innym ni\u017c niesparametryzowana klasa\/interfejs lub typ surowy).<\/em> <\/strong><\/p>\nDo wpisywania mo\u017cna u\u017cywa\u0107 typ\u00f3w sparametryzowanych za pomoc\u0105 symboli wieloznacznych (takich jak niesparametryzowane klasy i interfejsy):<\/p>\n
\n- jako argumenty i metody zwracane<\/li>\n
- jako typ pola lub lokalna zmienna referencyjna<\/li>\n
- jako typ komponentu tablicy jako argument typu innych sparametryzowanych typ\u00f3w<\/li>\n
- jako typ celu w rzutach<\/li>\n<\/ul>\n
Nie tylko typy mog\u0105 by\u0107 og\u00f3lne, ale metody r\u00f3wnie\u017c mog\u0105 by\u0107 og\u00f3lne. Metody statyczne i niestatyczne, a tak\u017ce konstruktory mog\u0105 mie\u0107 parametry typu. Sk\u0142adnia deklaracji parametr\u00f3w typu formalnego jest podobna do sk\u0142adni typ\u00f3w og\u00f3lnych. Sekcja parametru typu jest ograniczona nawiasami ostrymi i pojawia si\u0119 przed typem zwracanym przez metod\u0119. Jego sk\u0142adnia i znaczenie s\u0105 identyczne z list\u0105 parametr\u00f3w typu og\u00f3lnego.<\/p>\n
Oto przyk\u0142ad rodzaju og\u00f3lnego maks<\/tt> metoda obliczaj\u0105ca najwi\u0119ksz\u0105 warto\u015b\u0107 w kolekcji element\u00f3w nieznanego typu A<\/tt> .<\/p>\n
Przyk\u0142ad (metody og\u00f3lnej):<\/p>\n
Kolekcje klas {<\/tt>
\n \u00a0 publiczna statyka <A rozszerza Por\u00f3wnywalny<A>> A<\/span> <\/b> max(Kolekcja< 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 podczas gdy (xi.hasNext()) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 A<\/span> <\/b> x = xi.nast\u0119pny();<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0 if (w.compareTo(x) < 0) w = x;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0 powr\u00f3t w;<\/tt>
\n \u00a0 }<\/tt>
\n }\u00a0<\/tt><\/p><\/blockquote>\nThe maks<\/tt> metoda ma jeden parametr typu o nazwie A<\/tt> .\u00a0 Jest to symbol zast\u0119pczy typu elementu kolekcji, na kt\u00f3rym dzia\u0142a metoda. Parametr typu ma ograniczenie; musi to by\u0107 typ b\u0119d\u0105cy podtypem Por\u00f3wnywalne<A><\/tt><\/p>\n
Przyk\u0142ad (tego samego typu og\u00f3lnego, tym razem z<\/i> miedza):<\/p>\n interfejs publiczny Por\u00f3wnywalny<T> {<\/tt>
\n \u00a0 public int CompareTo(T arg);<\/tt>
\n }<\/tt>
\n klasa publiczna TreeMap<Key rozszerza Comparable<Key><\/span> <\/b> ,Dane>{<\/tt>
\n \u00a0 prywatna klasa statyczna Entry<K,V> {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 klawisz K;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 warto\u015b\u0107 V;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Wpis<K,V> lewy = null;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Wpis<K,V> prawo = null;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Wpis<K,V> rodzic;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 prywatny przej\u015bciowy wpis<Key,Data> root = null;<\/tt>
\n \u00a0 ...<\/tt>
\n \u00a0 prywatny wpis<Key,Data> getEntry(klucz kluczowy) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Entry<Key,Data> p = root;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 Klucz k = klucz;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 podczas gdy (p!= null) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 int cmp = k. por\u00f3wnajTo(p.key)<\/span> <\/b> ;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 je\u015bli (cmp == 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 zwr\u00f3\u0107 p;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 else if (cmp < 0)<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 p = p.lewy;<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 w przeciwnym razie\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 p = p.prawo;\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 }<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 zwr\u00f3\u0107 warto\u015b\u0107 zerow\u0105;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 publiczna warto\u015b\u0107 logiczna zawieraKey(Klucz kluczowy) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 zwr\u00f3\u0107 getEntry(key) != null;<\/tt>
\n \u00a0 }<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\nW powy\u017cszym przyk\u0142adzie parametr type Klawisz<\/tt> ma granic\u0119 Por\u00f3wnywalny<Key><\/tt> .\u00a0 Specyfikacja granicy ma dwa skutki:<\/p>\n\n- Daje dost\u0119p do metod okre\u015blonych przez powi\u0105zanie<\/i> .\u00a0 W przyk\u0142adzie zwi\u0105zany Por\u00f3wnywalny<Key> <\/tt> daje dost\u0119p do por\u00f3wnaj<\/tt> metod\u0119, kt\u00f3r\u0105 chcemy wywo\u0142a\u0107 przy implementacji naszego Mapa Drzewa<\/tt> klasa.<\/li>\n<\/ul>\n
\n- Do tworzenia instancji typu og\u00f3lnego mo\u017cna u\u017cywa\u0107 tylko typ\u00f3w \u201ew granicach\u201d.<\/i> \u00a0 W przyk\u0142adzie sparametryzowany typ, taki jak TreeMap<Number,String><\/tt> zosta\u0142by odrzucony, poniewa\u017c typ Numer<\/tt> nie jest podtypem Por\u00f3wnywalny<Numer><\/tt> .\u00a0 Typ sparametryzowany, taki jak TreeMap<String,String><\/tt> zosta\u0142by zaakceptowany, poniewa\u017c typ String mie\u015bci si\u0119 w okre\u015blonych granicach, tj. jest podtypem Por\u00f3wnywalne<String><\/tt> .<\/li>\n<\/ul>\n
Wszystkie klasy, interfejsy i typy wyliczeniowe mog\u0105 by\u0107 u\u017cywane jako powi\u0105zane parametry typu, w tym typy zagnie\u017cd\u017cone i wewn\u0119trzne.\u00a0 Ani typy pierwotne, ani typy tablicowe nie mog\u0105 by\u0107 u\u017cywane jako powi\u0105zane parametry typu.<\/p>\n
Przyk\u0142ady (ogranicze\u0144 parametr\u00f3w typu):<\/p>\n
rozszerza si\u0119 klasa X0 <T wew<\/span> <\/b> > { ... }\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ b\u0142\u0105d<\/span> <\/b> <\/tt>
\n rozszerza si\u0119 klasa X1 <T Obiekt[]<\/span> <\/b> > { ... } \/\/ b\u0142\u0105d<\/span> <\/b> <\/tt>
\n rozszerza si\u0119 klasa X2 <T Numer<\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X3 <T Smyczkowy<\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X4 <T Mo\u017cliwo\u015b\u0107 uruchomienia<\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X5 <T Stan w\u0105tku<\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X6 <T Lista<\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X7 <T Lista<String><\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X8 <T Lista<? rozszerza numer ><\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X9 <T Por\u00f3wnywalny<? super numer><\/span> <\/b> > { ... }<\/tt>
\n rozszerza si\u0119 klasa X10<T Mapa.Wpis<?,?><\/span> <\/b> > { ... }<\/tt><\/p><\/blockquote>\nPrzyk\u0142adowy kod pokazuje, \u017ce typy pierwotne, takie jak wew<\/tt> i typy tablic, takie jak Obiekt[] <\/tt> nie s\u0105 dozwolone jako powi\u0105zane z parametrem typu.<\/p>\n
Typy klas, np Numer<\/tt> Lub Smyczkowy<\/tt> i typy interfejs\u00f3w, takie jak Mo\u017cliwo\u015b\u0107 uruchomienia<\/tt> , s\u0105 dozwolone jako powi\u0105zane z parametrem typu.<\/p>\n
Typy wyliczeniowe, takie jak Stan w\u0105tku<\/tt> s\u0105 r\u00f3wnie\u017c dozwolone jako powi\u0105zane z parametrami typu. Stan w\u0105tku<\/tt> jest przyk\u0142adem typu zagnie\u017cd\u017conego u\u017cywanego jako powi\u0105zany parametr typu.\u00a0 Dozwolone s\u0105 r\u00f3wnie\u017c niestatyczne typy wewn\u0119trzne.<\/p>\n
Typy surowe s\u0105 dozwolone jako powi\u0105zane z parametrami typu; Lista<\/span> <\/tt> jest przyk\u0142adem.<\/p>\nTypy parametryczne s\u0105 dozwolone jako powi\u0105zane z parametrami typu, w tym konkretne typy sparametryzowane, takie jak Lista<String><\/tt> , ograniczone typy parametryczne z symbolami wieloznacznymi, takie jak Lista<? rozszerza numer ><\/tt> I Por\u00f3wnywalny<? super Long><\/tt> i nieograniczone typy parametryczne z symbolami wieloznacznymi, takie jak Mapa.Wpis<?,?><\/tt> .\u00a0 Powi\u0105zanie, kt\u00f3re jest typem sparametryzowanym za pomoc\u0105 symbolu wieloznacznego, dopuszcza jako argument typu wszystkie typy nale\u017c\u0105ce do rodziny typ\u00f3w oznaczanej przez symbol wieloznaczny.\u00a0 Powi\u0105zanie typu sparametryzowanego za pomoc\u0105 symbolu wieloznacznego zapewnia jedynie ograniczony dost\u0119p do p\u00f3l i metod; ograniczenia zale\u017c\u0105 od rodzaju symbolu wieloznacznego.<\/p>\n
Przyk\u0142ad (typu sparametryzowanego za pomoc\u0105 symboli wieloznacznych jako powi\u0105zany parametr typu):<\/p>\n
klasa X< T rozszerza List<? rozszerza numer ><\/span> <\/b> > {<\/tt>
\n \u00a0 public void SomeMethod(T t) {<\/tt>
\n \u00a0\u00a0\u00a0 t.add(nowy d\u0142ugi(0L));\u00a0\u00a0\u00a0 \/\/ b\u0142\u0105d<\/span> <\/b> <\/tt>
\n \u00a0\u00a0\u00a0 Liczba n = t.usu\u0144(0);<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt>
\n pr\u00f3ba klasowa {<\/tt>
\n \u00a0 public static void main(String[] args) {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0 <\/span> <\/b> X<ArrayList<<\/span> D\u0142ugi<\/span> <\/b> >> x1 = nowy X<ArrayList<Long>>();\u00a0<\/span> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0 X<ArrayList<<\/span> Smyczkowy<\/span> <\/b> >> x2 = nowy X<ArrayList<String>>(); <\/span> \/\/ b\u0142\u0105d<\/span> <\/b> <\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nZmienne referencyjne typu T <\/tt> (parametr typu) s\u0105 traktowane jak zmienne referencyjne typu wieloznacznego (powi\u0105zanie parametru typu).\u00a0 W naszym przyk\u0142adzie konsekwencj\u0105 jest to, \u017ce kompilator odrzuca wywo\u0142anie metod, kt\u00f3re przyjmuj\u0105 argument \u201enieznanego\u201d typu, kt\u00f3ry oznacza parametr typu, np. Lista.dodaj<\/tt> , poniewa\u017c granica jest typem sparametryzowanym za pomoc\u0105 symboli wieloznacznych z g\u00f3rn\u0105 granic\u0105.
\nJednocze\u015bnie zwi\u0105zany Lista<? rozszerza numer ><\/tt> okre\u015bla typy, kt\u00f3re mog\u0105 by\u0107 u\u017cywane jako argumenty typu. Kompilator akceptuje wszystkie argumenty typu nale\u017c\u0105ce do rodziny typ\u00f3w Lista<? rozszerza numer ><\/tt> , czyli wszystkie podtypy Lista<\/tt> z argumentem typu, kt\u00f3ry jest podtypem Numer<\/tt> .<\/p>\n
Parametr typu mo\u017ce s\u0142u\u017cy\u0107 jako granica innego parametru typu.<\/p>\n
Przyk\u0142ad (parametru typu u\u017cytego jako powi\u0105zanie parametru typu):<\/p>\n
klasa Tr\u00f3jka <T><\/b> {<\/tt>
\n \u00a0 prywatny T fst, snd, trd;<\/tt>
\n \u00a0 publiczny < U<\/b> rozci\u0105ga T<\/span> <\/b> , V rozci\u0105ga T<\/span> <\/b> , W rozci\u0105ga T<\/span> <\/b> > Potr\u00f3jny(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>\nW tym przyk\u0142adzie parametr typu T<\/tt> klasy sparametryzowanej jest u\u017cywana jako granica parametr\u00f3w typu U<\/tt> ,\u00a0 V<\/tt> I W<\/tt> sparametryzowanej metody instancji tej klasy.<\/p>\n
Dalsze mo\u017cliwo\u015bci u\u017cycia parametr\u00f3w typu jako granic innych parametr\u00f3w typu obejmuj\u0105 sytuacje, w kt\u00f3rych typ zagnie\u017cd\u017cony jest zdefiniowany w typie og\u00f3lnym lub klasa lokalna jest zdefiniowana w metodzie og\u00f3lnej.\u00a0 Dozwolone jest nawet u\u017cycie parametru typu jako powi\u0105zania innego parametru typu w tej samej sekcji parametru typu.<\/p>\n
Powi\u0105zanie b\u0119d\u0105ce klas\u0105 zapewnia dost\u0119p do wszystkich jej publicznych element\u00f3w cz\u0142onkowskich, czyli publicznych p\u00f3l, metod i typ\u00f3w zagnie\u017cd\u017conych. Nie s\u0105 dost\u0119pne tylko konstruktory, poniewa\u017c nie ma gwarancji, \u017ce podklasa powi\u0105zania ma te same konstruktory co powi\u0105zanie.<\/p>\n
Przyk\u0142ad (klasy u\u017cytej jako granica parametru typu):<\/p>\n
klasa publiczna Superklasa<\/span> {<\/tt> \u00a0\u00a0\u00a0 \/\/ elementy statyczne<\/tt>
\n \u00a0\u00a0\u00a0 publiczne wyliczenie EnumType {TO, TO}<\/tt>
\n \u00a0\u00a0\u00a0 publiczny obiekt statyczny staticField;<\/tt>
\n \u00a0\u00a0\u00a0 public static void staticMethod() { ... }<\/tt><\/p>\n \u00a0\u00a0\u00a0 \/\/ elementy niestatyczne<\/tt>
\n \u00a0\u00a0\u00a0 klasa publiczna InnerClass { ... }<\/tt>
\n \u00a0\u00a0\u00a0 Obiekt publiczny nonStaticField;<\/tt>
\n \u00a0\u00a0\u00a0 public void nonStaticMethod() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ konstruktorzy<\/tt>
\n \u00a0\u00a0\u00a0 publiczna SuperKlasa() { ... }<\/tt><\/p>\n
\u00a0\u00a0\u00a0 \/\/ cz\u0142onkowie prywatni<\/tt>
\n \u00a0\u00a0\u00a0 prywatny Obiekt privateField;\u00a0<\/tt><\/p>\n
\u00a0\u00a0\u00a0 ...<\/tt>
\n }<\/tt><\/p>\n
publiczna klasa ko\u0144cowa SomeClass<T rozszerza si\u0119 Superklasa<\/span> <\/b> > {<\/tt>
\n \u00a0\u00a0\u00a0 prywatny obiekt T;<\/tt>
\n \u00a0\u00a0\u00a0 public SomeClass(T t) { obiekt = t; }\u00a0<\/tt><\/p>\n \u00a0\u00a0\u00a0 publiczny ci\u0105g toString() {<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 powr\u00f3t<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \"statyczny typ zagnie\u017cd\u017cony\u00a0\u00a0\u00a0 : \"+T.EnumType.class+\"\\n\"\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"pole statyczne\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \u201e+T.staticField+\u201d\\n\u201d<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"metoda statyczna\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \u201e+T.staticMethod()+\u201d\\n\u201d<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"niestatyczny typ zagnie\u017cd\u017cony: \"+T.InnerClass.class+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"pole niestatyczne\u00a0\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticField+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"metoda niestatyczna\u00a0\u00a0\u00a0\u00a0 : \"+object.nonStaticMethod()+\"\\n\"<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"konstruktor\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \u201e+(nowy T())+\u201d\\n\u201d\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ b\u0142\u0105d<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 +\"private member\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 : \u201e+object.privateField+\u201d\\n\u201d\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ b\u0142\u0105d\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ;<\/tt>
\n \u00a0\u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Zwi\u0105zany Superklasa<\/tt> daje dost\u0119p do typ\u00f3w zagnie\u017cd\u017conych, p\u00f3l i metod statycznych oraz p\u00f3l i metod niestatycznych.\u00a0 Tylko konstruktor nie jest dost\u0119pny.\u00a0 Dzieje si\u0119 tak, poniewa\u017c konstruktory nie s\u0105 dziedziczone. Ka\u017cda podklasa definiuje swoje w\u0142asne konstruktory i nie musi obs\u0142ugiwa\u0107 konstruktor\u00f3w swojej nadklasy.\u00a0 Dlatego nie ma gwarancji, \u017ce podklasa Superklasa<\/tt> b\u0119dzie mia\u0142 tego samego konstruktora, co jego nadklasa.<\/p>\n
Kontekst, w kt\u00f3rym Enum<E rozszerza Enum<E>><\/tt> ” pojawia si\u0119 deklaracja Wyliczenie<\/tt> klasa w pakiecie java.lang<\/tt> :<\/p>\n publiczna klasa abstrakcyjna Enum<E rozszerza Enum<E>><\/b> {<\/tt>
\n \u00a0 ...<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Typ Wyliczenie<\/tt> jest wsp\u00f3ln\u0105 klas\u0105 bazow\u0105 wszystkich typ\u00f3w wyliczeniowych.\u00a0 W Javie typ wyliczeniowy, taki jak Kolor<\/tt> jest t\u0142umaczone na klas\u0119 Kolor<\/tt> to si\u0119 rozci\u0105ga Wyliczenie<Kolor><\/tt> . Cel nadklasy Wyliczenie<\/tt> jest zapewnienie funkcjonalno\u015bci wsp\u00f3lnej dla wszystkich typ\u00f3w wylicze\u0144.<\/p>\n
Oto szkic zaj\u0119\u0107 Wyliczenie<\/tt> :<\/p>\n publiczna klasa abstrakcyjna Enum< mi<\/span> rozszerza Enum<E>><\/b> implementuje Comparable< mi<\/span> <\/b> >, serializowany {<\/tt>
\n \u00a0 prywatna ko\u0144cowa nazwa ci\u0105gu;<\/tt>
\n \u00a0 publiczny ko\u0144cowy ci\u0105g nazwa() { ... }<\/tt> \u00a0 prywatny ko\u0144cowy int porz\u0105dkowy;<\/tt>
\n \u00a0 public final int ordinal() { ... }<\/tt><\/p>\n \u00a0 chronione wyliczenie (nazwa ci\u0105gu, liczba ca\u0142kowita) { ... }<\/tt><\/p>\n
\u00a0 public String\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 toString() { ... }<\/tt>
\n \u00a0 publiczna ko\u0144cowa warto\u015b\u0107 logiczna r\u00f3wna si\u0119 (obiekt inny) { ... }<\/tt>
\n \u00a0 publiczny ko\u0144cowy int hashCode() { ... }<\/tt>
\n \u00a0 chroniony obiekt ko\u0144cowy clone() zg\u0142asza wyj\u0105tek CloneNotSupportedException { ... }<\/tt>
\n \u00a0 publiczny fina\u0142 in CompareTo( mi<\/span> <\/b> o) { ... }<\/tt><\/p>\n \u00a0 publiczny fina\u0142 Class< mi<\/span> <\/b> > getDeclaringClass() { ... }<\/tt>
\n \u00a0 public static <T rozszerza Enum<T>> T warto\u015b\u0107Of(Class<T> enumType, nazwa ci\u0105gu) { ... }<\/tt>
\n }<\/tt><\/p><\/blockquote>\nZaskakuj\u0105ca cecha w deklaracji \u201e Enum<E rozszerza Enum<E>><\/tt> ” jest faktem, \u017ce nowo zdefiniowana klasa Wyliczenie<\/tt> i jego nowo zdefiniowany parametr typu mi <\/tt> pojawiaj\u0105 si\u0119 w granicy tego samego parametru typu.\u00a0 Oznacza to, \u017ce Wyliczenie<\/tt> typ musi zosta\u0107 utworzony dla jednego z jego podtyp\u00f3w.\u00a0 Aby zrozumie\u0107, dlaczego ma to sens, nale\u017cy wzi\u0105\u0107 pod uwag\u0119, \u017ce ka\u017cdy typ wyliczeniowy jest t\u0142umaczony na podtyp Wyliczenie<\/tt> .<\/p>\n
Oto wymy\u015blony typ wyliczeniowy Kolor<\/tt> :<\/p>\n wyliczenie Kolor<\/b> {CZERWONY, NIEBIESKI, ZIELONY}<\/tt><\/p><\/blockquote>\n
Kompilator t\u0142umaczy to na nast\u0119puj\u0105c\u0105 klas\u0119:<\/p>\n
publiczne zaj\u0119cia ko\u0144cowe Kolor<\/b> rozci\u0105ga si\u0119 Wyliczenie<Kolor><\/b> {<\/tt>
\n \u00a0 public static final Color[] warto\u015bci() { return (Color[])$VALUES.clone(); }<\/tt>
\n \u00a0 public static Warto\u015b\u0107 koloru (nazwa ci\u0105gu) { ... }<\/tt> \u00a0 private Color(String s, int i) { super(s, i); }<\/tt><\/p>\n
\u00a0 publiczny statyczny ko\u0144cowy Kolor CZERWONY;<\/tt>
\n \u00a0 publiczny statyczny ko\u0144cowy Kolor NIEBIESKI;<\/tt>
\n \u00a0 publiczny statyczny ko\u0144cowy Kolor ZIELONY;<\/tt><\/p>\n
\u00a0 prywatny statyczny ko\u0144cowy Kolor $VALUES[];<\/tt><\/p>\n
\u00a0 statyczny {<\/tt>
\n \u00a0\u00a0\u00a0 CZERWONY = nowy kolor(\"CZERWONY\", 0);<\/tt>
\n \u00a0\u00a0\u00a0 NIEBIESKI = nowy kolor(\"NIEBIESKI\", 1);<\/tt>
\n \u00a0\u00a0\u00a0 ZIELONY = nowy kolor(\"ZIELONY\", 2);<\/tt>
\n \u00a0\u00a0\u00a0 $WARTO\u015aCI = (nowy kolor[] { CZERWONY, NIEBIESKI, ZIELONY });<\/tt>
\n \u00a0 }<\/tt>
\n }<\/tt><\/p><\/blockquote>\n
Dziedziczenie ma ten skutek, \u017ce Kolor<\/tt> typ dziedziczy wszystkie metody zaimplementowane w Wyliczenie<Kolor><\/tt> .\u00a0 W\u015br\u00f3d nich jest por\u00f3wnaj<\/tt> metoda.\u00a0 The Kolor. por\u00f3wnaj<\/tt> metoda powinna prawdopodobnie zaj\u0105\u0107 a Kolor<\/tt> jako argument.\u00a0 Aby tak si\u0119 sta\u0142o, klasa Wyliczenie<\/tt> jest og\u00f3lny i Wylicz.por\u00f3wnajTo<\/tt> metoda trwa Wyliczenie<\/tt> parametr typu mi <\/tt> jako argument.\u00a0 W rezultacie wpisz Kolor<\/tt> pochodz\u0105ce z Wyliczenie<Kolor><\/tt> dziedziczy A por\u00f3wnaj<\/tt> metoda, kt\u00f3ra wymaga a Kolor<\/tt> i argumentacja, dok\u0142adnie tak, jak powinna.
\nJe\u015bli przeanalizujemy deklaracj\u0119 \u201e Enum<E rozszerza Enum<E>><\/tt> \u201eWidzimy, \u017ce ten wz\u00f3r ma kilka aspekt\u00f3w.<\/p>\n
Po pierwsze, zwi\u0105zanym parametrem typu jest sam typ: “ Wyliczenie<\/b> <E rozszerza si\u0119 Wyliczenie<\/b> <E>><\/tt> “. Zapewnia, \u017ce \u200b\u200btylko podtypy typu Wyliczenie<\/tt> s\u0105 dozwolone jako argumenty typu. (Teoretycznie wpisz Wyliczenie<\/tt> mo\u017cna utworzy\u0107 instancj\u0119 sam\u0105 w sobie, jak in Wyliczenie<Enum><\/tt> , ale z pewno\u015bci\u0105 nie jest to zamierzone i trudno sobie wyobrazi\u0107 sytuacj\u0119, w kt\u00f3rej taka instancja by\u0142aby u\u017cyteczna.)<\/p>\n
Po drugie, istnieje fakt, \u017ce typ zwi\u0105zany z parametrami jest typem sparametryzowanym Wyliczenie <E><\/b> <\/tt> , kt\u00f3ry u\u017cywa parametru type mi<\/tt> jako argument typu powi\u0105zania. Ta deklaracja gwarantuje, \u017ce relacja dziedziczenia mi\u0119dzy podtypem a instancj\u0105 Wyliczenie<\/tt> jest w formie X rozszerza Enum<X><\/tt> \u201e. Podtyp taki jak \u201e X rozszerza Enum<Y><\/tt> ” nie mo\u017cna zadeklarowa\u0107 ze wzgl\u0119du na argument typu Y<\/tt> nie mie\u015bci\u0142oby si\u0119 w granicach; tylko podtypy Wyliczenie<X><\/tt> mieszcz\u0105 si\u0119 w granicach.<\/p>\n
Po trzecie, faktem jest, \u017ce Wyliczenie<\/tt> ma przede wszystkim charakter og\u00f3lny.\u00a0 Oznacza to, \u017ce niekt\u00f3re metody klasy Wyliczenie<\/tt> przyj\u0105\u0107 argument lub zwr\u00f3ci\u0107 warto\u015b\u0107 nieznanego typu (lub w inny spos\u00f3b zale\u017ce\u0107 od nieznanego typu). Jak ju\u017c wiemy, ten nieznany typ b\u0119dzie p\u00f3\u017aniej podtypem X<\/tt> z Wyliczenie<X><\/tt> .\u00a0 St\u0105d w typie sparametryzowanym Wyliczenie<X><\/tt> , metody te obejmuj\u0105 podtyp X<\/tt> i s\u0105 dziedziczone do podtypu X<\/tt> .\u00a0 The por\u00f3wnaj<\/tt> metoda jest przyk\u0142adem takiej metody; jest dziedziczona z nadklasy do ka\u017cdej podklasy i w ka\u017cdym przypadku ma sygnatur\u0119 specyficzn\u0105 dla podklasy.<\/p>\n
Podsumowuj\u0105c, o\u015bwiadczenie \u201e Enum<E rozszerza Enum<E>><\/tt> ” mo\u017cna rozszyfrowa\u0107 jako: Wyliczenie<\/tt> to typ og\u00f3lny, kt\u00f3ry mo\u017cna utworzy\u0107 tylko dla jego podtyp\u00f3w, a te podtypy odziedzicz\u0105 kilka przydatnych metod, z kt\u00f3rych niekt\u00f3re przyjmuj\u0105 argumenty specyficzne dla podtypu (lub w inny spos\u00f3b zale\u017c\u0105 od podtypu).<\/p>\n
Parametry typu dolnej granicy klas<\/b><\/p>\n
Parametry typu mog\u0105 mie\u0107 kilka ogranicze\u0144, np. in klasa Box<T rozszerza Number> {...}<\/tt> . Ale parametr typu nie mo\u017ce mie\u0107 dolnej granicy, to znaczy konstrukcji takiej jak klasa Box<T \u015awietnie<\/b> Numer> {...}<\/tt> jest niedozwolone.\u00a0 Dlaczego nie?\u00a0 Odpowied\u017a brzmi: nie ma to sensu, bo nic by nie kupi\u0142o, gdyby by\u0142o dozwolone.\u00a0 Zobaczmy, dlaczego dolna granica parametr\u00f3w typu klas jest myl\u0105ca, badaj\u0105c, co oznacza g\u00f3rna granica parametru typu.<\/p>\n
G\u00f3rna granica parametru typu ma trzy skutki:<\/p>\n
\n\n- Ograniczona instancja.<\/i> <\/b> G\u00f3rna granica ogranicza zestaw typ\u00f3w, kt\u00f3rych mo\u017cna u\u017cy\u0107 do utworzenia instancji typu og\u00f3lnego.\u00a0 Je\u017celi zadeklarujemy a klasa Box<T rozszerza Number> {...} <\/tt> wtedy kompilator upewni\u0142by si\u0119, \u017ce tylko podtypy Numer<\/tt> mo\u017ce by\u0107 u\u017cyty jako argument typu.\u00a0 To znaczy, Pude\u0142ko<Numer><\/tt> lub Pude\u0142ko<D\u0142ugie><\/tt> jest dozwolone, ale a Pole<Object><\/tt> Lub Pude\u0142ko<String><\/tt> zosta\u0142oby odrzucone<\/li>\n<\/ol>\n<\/ol>\n
Przyk\u0142ad (ograniczonego tworzenia instancji ze wzgl\u0119du na g\u00f3rn\u0105 granic\u0119 parametru typu):
\n klasa Box<T rozszerza Number> {\u00a0<\/tt>
\n \u00a0\u00a0 prywatna warto\u015b\u0107 T;\u00a0<\/tt>
\n \u00a0\u00a0 public Box(T t) { warto\u015b\u0107 = t; }\u00a0<\/tt>
\n \u00a0\u00a0 ...<\/tt>
\n }\u00a0<\/tt> pr\u00f3ba klasowa {\u00a0<\/tt>
\n \u00a0\u00a0 public static void main(String[] args) {\u00a0<\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<Long> boxOfLong = nowy Box<Long>(0L);\u00a0\u00a0 \/\/ Cienki<\/b> <\/tt>
\n \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 Box<String> boxOfString = nowy Box<String>(\"\"); \/\/ b\u0142\u0105d: ci\u0105g znak\u00f3w nie mie\u015bci si\u0119 w granicach<\/span> <\/b> <\/tt>
\n \u00a0\u00a0 }<\/tt>
\n }<\/tt><\/p>\n\n- Dost\u0119p do cz\u0142onk\u00f3w niestatycznych. <\/i> <\/b> G\u00f3rna granica daje dost\u0119p do wszystkich publicznych niestatycznych metod i p\u00f3l g\u00f3rnej granicy.\u00a0 W realizacji naszego klasa Box<T rozszerza Number> {...}<\/tt> mo\u017cemy wywo\u0142a\u0107 wszystkie publiczne metody niestatyczne zdefiniowane w klasie Numer<\/tt> , takie jak intValue()<\/tt> na przyk\u0142ad.\u00a0 Bez g\u00f3rnej granicy kompilator odrzuci\u0142by ka\u017cde takie wywo\u0142anie. Przyk\u0142ad (dost\u0119pu do element\u00f3w niestatycznych ze wzgl\u0119du na g\u00f3rn\u0105 granic\u0119 parametru typu):<\/li>\n<\/ol>\n
klasa Box<T rozszerza Number> {\u00a0<\/tt>
\n \u00a0\u00a0 prywatna warto\u015b\u0107 T;\u00a0<\/tt>
\n \u00a0\u00a0 public Box(T t) { warto\u015b\u0107 = t; }\u00a0<\/tt>
\n \u00a0\u00a0 public int inkrementacja() { return value.intValue()+1; } \/\/ <= by\u0142oby b\u0142\u0119dem bez ograniczenia liczby<\/b> <\/tt>
\n \u00a0\u00a0 ...<\/tt>