Generice Java explicate pe scurt cu exemple

Vă rugăm să consultați aceste întrebări frecvente pentru mai multe informații:

http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html#SECTION1

Iată câteva puncte importante din această întrebare frecventă.

Exemplu (de tip generic):

clasa Pair<X,Y> { 
  privat X mai întâi;
  privat Y secundă;   public Pair(X a1, Y a2) {
    primul = a1;
    secunda = a2;
  }
  public X getFirst() { return first; }
  public Y getSecond() { return second; }
  public void setFirst(X arg)  { first = arg; }
  public void setSecond(Y arg) { secunda = arg; }
}

Clasa Pereche are doi parametri de tip X şi Y .  Ele sunt înlocuite cu argumente de tip atunci când tipul generic Pereche este instanțiată. De exemplu, în declarație Pair<String, Data> parametrul tip X este înlocuit cu argumentul tip Şir şi Y este înlocuit cu  Data .
Domeniul de aplicare al identificatorilor X şi Y este întreaga definiţie a clasei.  În acest scop cei doi parametri de tip X şi Y sunt fousete ca și cum ar fi tipuri (cu unele restricții). În exemplul de mai sus, parametrii de tip sunt utilizați ca argument și tipul de returnare a metodelor de instanță și tipuri de câmpuri de instanță.
Parametrii de tip pot fi declarați cu limită. Limitele oferă acces la metoda de tip unknown pe care îl reprezintă parametrul tip. În exemplul nostru, nu invocăm nicio metodă necunoscută X şi Y . Din acest motiv, cei doi parametri de tip sunt nelimitați.

Exemplu (de tip concret parametrisat):

public void printPair( Pair<String,Long> pereche) {
  System.out.println("("+pereche.getFirst()+","+pereche.getSecond()+")");
} Pair<String,Long> limit = nou Pair<String,Long> ("maxim", 1024L);
printPair(limita);

Exemplu (de tipul parametrizat cu wildcard):

public void printPair( Pereche<?,?> pereche) {
  System.out.println("("+pereche.getFirst()+","+pereche.getSecond()+")");
} Pereche<?,?> limit = nou Pair<String,Long> ("maxim", 1024L);
printPair(limita);

Toate instanțiile de tip generic au aceeași reprezentare a tipului de rulare, și anume reprezentarea tipului brut. De exemplu, instanțiile unui tip generic Listă , ca Listă<Date> , List<String> , List<Long> , etc. au diferite tipuri statice în timpul compilării, dar același tip dinamic Listă în timpul conducerii.

Distribuția este formatată în două părți:

  • o verificare de tip static efectuată de compilator în timpul compilării și
  • o verificare dinamică a tipului efectuată de mașina virtuală în timpul execuției.

Partea statică sortează distribuțiile fără sens, care nu pot reuși, cum ar fi distribuția de la Şir că Data sau din List<String> că Listă<Date> .

Partea dinamică uses the information despre tipul de rulare și perform o verificare a tipului în timpul rularei.  Ridică-te o ClassCastException dacă tipul dinamic al obiectului nu este tipul țintă (sau un subtip al tipului țintă) al proiecției. Exemple de modele cu o parte dinamică sunt turnarea din Obiect că Şir sau din Obiect că List<String> .  Acestea sunt așa-numitele downcasts, de la un supertip la un subtip.

Exemple de tipi concrete parametrizate sunt List<String> , Hartă<String,Data> , dar nu List<? extinde Number> sau Map<String,?> .

Atalud este de astepzat ca a List<Obiect> ar fi un supertip de a List<String> , pentru că Obiect este un supertip de Şir .  Această așteptare provine din faptul că un astfel de tip de relație există pentru matrice:  Obiect[] este un supertip de Şir[] , pentru că Obiect este un supertip de Şir . (Acest tip de relație este cunoscut ca covarianta .) Relația super-subtip a tipurilor de componente se extinde în tipurile de matrice corespunzătoare. Nu există o astfel de relație de tip pentru instanțierea tipurilor generice. (Tipurile parametrizate sunt nu covariant.)

Lipsa unei relații de super-subtip între instanciële de same tip generic are consecințe diferite.  Iată un exemplu.

Exemplu:

void printAll(ArrayList<Object> c) {
  pentru (Obiect o : c) 
    System.out.println(o);
} ArrayList<String> list = nou ArrayList<String>();
... lista de completare...
printAll(lista);   // eroare

O ArrayList<String> obiectul nu poate fi transmis ca argument unei metode care solicită a ArrayList<Object> deoarece cele două tipuri sunt instanțieri de același tip generic, dar pentru diferit tastati arguments si din acest motiv nu sunt compatibile intre ele.

Tipurile parametrizate concrete sunt instantieri concrete de tip generic.  Aproape că nu există tipuri; există doar câteva restricții.  Ele NU poate fi utilizat în următoarele scopuri:

  • pentru crearea de tablouri
  • în tratarea excepţiilor
  • într-o clasă literală
  • într-o instanţă de expresie

Matricele care contain elements al cómbe tip este un tip parametrizat concret sunt ilegale.

Exemplu (de type de matrix illegal):

test static void() {
  Pereche<Integer,Integer>[] intPairArr = nou Pereche<Integer,Integer>[10] ; // eroare
  addElements(intPairArr); 
  Pair<Integer,Integer> pereche = intPairArr[1];
  Integer i = pair.getFirst();
  pair.setSecond(i);
}
static void addElements( Obiect[] objArr) {
  objArr[0] = pereche nouă<Integer,Integer>(0,0);
  objArr[1] = pereche nouă<String,String>("","");      // ar trebui să eșueze cu ArrayStoreException
}

Compilatorul interzice crearea de tablouri al căror tip de componentă este un tip parametrizat concret, cum ar fi Pereche<Integer,Integer> în exemplul nostru.  Am discutat în intrarea anterioară de ce este rezonabil ca compilatorul să califice a Pereche<Integer,Integer>[] ca fiind ilegale.  Problema cheie este că compilatorul și sistemul de rulare trebuie să se asigure că o matrice este a omogen succesiune de elemente de același tip.  Una dintre verificările de tip, și anume verificarea matricei-magazin-magazin efectuată de mașina virtuală în timpul execuției, nu reușește să detecteze inserția ofensătoare a unui element străin. În exemplu, a doua inserare în addElements metoda ar trevui să eșueze, because he added o pereche de șiruri la o matrix de valori integrale, dar nu eșuează așa cum era de aștetat. Motivele au fost discutate în intrarea precedentă.

If nu putem folosi matrice care contain elements al cómbe tip este un tip parametrizat concret, ce folosim ca solution?

Să luăm în considerare 3 soluții posibile:

  • gamă de tipuri brute
  • matrice de tipul parametrizat cu wildcard nemărginit
  • colecție în loc de matrice

În timp ce matricele de tipi parametrizate din beton sunt illegale, collections de tipi parametrizate din beton sunt permise.

Un tip cu parametrii wildcard este o instanțiere a unui tip generic în care cel puțin un argument de tip este un wildcard.  Exemple de tipi parametrizate cu wildcard sunt Colecție<?> , List<? extinde Number> , Comparator<? super String> şi Pair<String,?> . Un tip parametrizat cu wildcard denotă o familie de tipuri care cuprinde instanțieri concrete de tip generic.  Tipul de wildcard utilizat determină ce tipuri concrete parametrizate aparțin familiei.  De exemplu, tipul parametrizat cu wildcard Colecție<?> denotă familia tuturor instanțiilor ale Colectare interfață indiferent de tipul de argument.  Tipul parametrizat cu wildcard List<? extinde Number> denotă familia tuturor tipurilor de listă în care tipul de element este un subtip al  Număr .  Tipul parametrizat cu wildcard Comparator<? super String> este familia tuturor instanțiilor ale Comparator interfață pentru tipurile de argument de tip care sunt supertipuri ale Şir.

Un tip parametrizat cu wildcard nu este un tip în sensul obișnuit (diferit de o clasă/interfață neparametrată sau de un tip brut).

Tipurile parametrizate cu wildcard pot fi folosite pentru tastare (cum ar fi clasele și interfețele neparametrate):

  • ca argument și tipuri de metode de returnare
  • ca tip de câmp sau variabilă de referință locală
  • ca tip component al unui argument de tip arrayas al altor tipuri parametrizate
  • ca tip țintă în turnări

Nu numai tipuri pot fi generice, dar și metodele pot fi generice. Metodele statice și nonstatice, precum și constructorii pot avea parametri de tip. Sintaxa pentru declararea parametrilor de tip formal este similară cu sinteza pentru tipuri generice. The section parametrului tip este delimitată de parenteze unghiulare și apare apăreșa tipului de returnare al metodei. Sintaxa și semnificația acesteia sunt identice cu lista de parametri de tip a unui tip generic.

Here is an exemplul unui generic max metodă care calculează cea mai mare valoare dintr-o colecție de elemente de tip necunoscut O .

Exemplu (de method generică):

colecții de clasă {
  static public <A extinde Comparable<A>> A max(Colecție< O > xs) {
    Iterator< O > xi = xs.iterator();
    O w = xi.next();
    în timp ce (xi.hasNext()) {
      O x = xi.next();
      dacă (w.compareTo(x) < 0) w = x;
    }
    returnează w;
  }
} 

The max metoda are un parametru de tip, numit O .  Este un loc pentru tipul de element al colecției la care funcționează metoda. Parametrul tip are o limită; trebuie să fie un tip care este un subtip al Comparabil<A>

Exemplu (de același tip generic, de data aceasta cu limite):

interfață publică Comparabil<T> {
  public int compareTo(T arg);
}
clasa publică TreeMap<Key extinde Comparable<Key> ,Data>{
  clasă statică privată Entry<K,V> {
     Tasta K;
     valoarea V;
     Intrare<K,V> stânga = nul;
     Intrare<K,V> dreapta = nul;
     Entry<K,V> părinte;
  }
  tranzitoriu privat Entry<Key,Data> root = null;
  ...
  private Entry<Key,Data> getEntry(cheie cheie) {
     Entry<Key,Data> p = root;
     Cheia k = cheie;
     în timp ce (p != nul) {
       int cmp = k. compareTo(p.key) ; 
       dacă (cmp == 0)
         întoarcere p;
       else if (cmp < 0)
         p = p.stânga;
       altfel 
         p = p.dreapta; 
     }
     returnează nul;
  }
  public boolean containsKey(Cheie cheie) {
     return getEntry(cheie) != null;
  }
  ...
}

În exemplul de mai sus, parametrul tip Cheie are legatul Comparabil<Key> .  Specificarea unei limite are două efecte:

  • Oferă acces la metodele pe care le specifică .  În exemplu, legatul Comparabil<Key> oferă acces la compara Cu metodă pe care dorim să o invocăm în implementarea programului nostru Harta copacului clasă.
  • Numai tipurile „în limite” pot fi folosite pentru instanțierea tipului generic.   În exemplu, un tip parametrizat, cum ar fi TreeMap<Number,String> ar fi respins, deoarece tipul Număr nu este un subtip de Comparabil<Number> .  Un tip parametrizat ca TreeMap<String,String> ar fi acceptat, deoarece tipul String este în limite, adică este un subtip al Comparabil<String> .

Toate clasele, interfezele și typuri de enumerare pot fi utilizare ca linii ale parametrilor de type, incluing the types imbricate și interne.  Nici tipurile primitive, nici tipurile de matrice nu pot fi folosite ca legat de parametru de tip.

Exemplu (de limit ale parametrilor de tip):

clasa X0 <T se extinde int > { ... }      // eroare
clasa X1 <T se extinde Obiect[] > { ... } // eroare
clasa X2 <T se extinde Număr > { ... }
clasa X3 <T se extinde Şir > { ... }
clasa X4 <T se extinde Rugabil > { ... }
clasa X5 <T se extinde Fire.State > { ... }
clasa X6 <T se extinde Listă > { ... }
clasa X7 <T se extinde List<String> > { ... }
clasa X8 <T se extinde List<? extinde Number> > { ... }
clasa X9 <T se extinde Comparabil<? super Număr> > { ... }
clasa X10<T se extinde Hartă.Intrare<?,?> > { ... }

Exemplul de cod arată că tipurile primitive, cum ar fi int și tipuri de matrice, cum ar fi Obiect[] nu sunt permit ca parametrul de tip legat.

Tipuri de class, cum ar fi Număr sau Şir , și tipuri de interfețe, cum ar fi Rugabil , sunt permit ca parametrul de tip legat.

Enum types, cum ar fi Fire.State sunt, de asemenea, permise ca parametru de tip legat. Fire.State este un exemplu de tip imbricat folosit ca legat de parametru de tip.  Sunt permit și typuri interior non-statice.

Tipurile brute sunt permit ca parametrul de tip limitat; Listă acesta este un exemplu.

Tipurile parametrizate sunt permise ca limitare a parametrilor de tip, inclusiv tipuri parametrizate concrete, cum ar fi List<String> , tipurile parametrizate cu caractere joker mărginite, cum ar fi List<? extinde Number> şi Comparabil<? super Long> și tipurile parametrizate cu caractere joker nelimitate, cum ar fi Hartă.Intrare<?,?> .  O limită care este un tip parametrizat cu wildcard permite ca argument de tip toate tipurile care belong to the familiei de tipuri pe care sau denotă wildcard.  Limitarea tipului parametrizat cu wildcard oferă doar acces restricționat la câmpuri și metode; the restrictions depind de tipul de wildcard.

Exemplu (de tipul parametrizat cu wildcard ca legat de parametru de tip):

clasa X< T extinde List<? extinde Number> > {
  public void someMethod(T t) {
    t.add(new Long(0L));    // eroare
    Numărul n = t.elimină(0);
  }
}
test de clasa {
  public static void main(String[] args) {
     X<ArrayList< Lung >> x1 = nou X<ArrayList<Long>>(); 
     X<ArrayList< Şir >> x2 = nou X<ArrayList<String>>(); // eroare
  }
}

Variabile de referință de tip T (parametrul de tip) sunt tratate ca variabile de referință de tip wildcard (parametrul de tip legat).  În exemplul nostru, consecința este că compilatorul respinge invocarea metodelor care iau un argument de tipul „necunoscut” pe care îl reprezintă parametrul de tip, cum ar fi Listă.adăugați , because limita este un tip parametrizat cu wildcard cu o limită superioară.
În același timp, legatul List<? extinde Number> determină tipurile care pot fi folosite ca argumente de tip. Compilatorul acceptă toate argumentele de tip care aparțin familiei de tip List<? extinde Number> , adică toate subtipurile de Listă cu un argument de tip care este un subtip de Număr .

Un parametru de tip poate fi utilizat ca limită a altui parametru de tip.

Exemplu (a unui parametru de tip utilizat ca legat de parametru de tip):

clasa Tripla <T> {
  private T fst, snd, trd;
  public < U extinde T , V extinde T , W extinde T > Triplu(U arg1, V arg2, W arg3) {
    fst = arg1;
    snd = arg2;
    trd = arg3;
  }
}

În acest exemplu, parametrul tip T al clasei parametrizate este folosit ca legat al parametrilor de tip U ,  V şi W a unei metode de instanță parametrizată a acelei clase.

Alte oportunități de utilizare a parametrilor de tip ca limite ale altui parametri de tip includ situații în care un tip imbricat este definit între unui tip generic sau local class este definit într-o metho generică.  Este chiar permisă utilizarea unui parametru de tip ca legat de un alt parametru de tip în aceeași secțiune a parametrului de tip.

O limită care este o clăsă oferă acces tuturor membrilor publicului său, adică câmpuri publice, metode și tipuri imbricate. Numai constructorii nu sunt accesibili deoarece nu există nicio garanție că subclasă a boundului sunt aceiași constructori ca bound.

Exemplu (al unei clase folosite ca limită a unui parametru de tip):

clasa publica SuperClass {     // membri statici
    enumerare publică EnumType {THIS, That}
    Public static Obiect staticField;
    public static void staticMethod() { ... }

    // membri nestatici
    clasă publică InnerClass { ... }
    Public Object nonStaticField;
    public void nonStaticMethod() { ... }

    // constructori
    public SuperClass() { ... }

    // membri privați
    private Object privateField; 

    ...
}

clasa finală publică SomeClass<T se extinde SuperClass > {
    obiect T privat;
    public SomeClass(T t) { obiect = t; } 

    public String toString() {
        reveni
         „tip imbricat static   : „+T.EnumType.class+”\n” 
        +"câmp static         : "+T.staticField+"\n"
        +"metoda statică        : "+T.staticMethod()+"\n"
        +"tip imbricat nestatic: "+T.InnerClass.class+"\n"
        +"câmp non-static     : "+object.nonStaticField+"\n"
        +"metoda non-statică    : "+object.nonStaticMethod()+"\n"
        +"constructor          : "+(nou T())+"\n"                   // eroare
        +"private member       : "+object.privateField+"\n"          // eroare 
        ;
    }
}

Legatul SuperClass oferă acces la tipurile imbricate, câmpurile și metodele statice și câmpurile și metodele non-statice.  Numai constructorul nu este accesibil.  Acest lucru se datorează faptului că constructorii nu sunt moșteniți. Fiecare subclasă își definește propriii constructori și nu trebuie să suporte constructorii superclasei sale.  Prin urmare, nu există nicio garanție că o subclasă de SuperClass va avea acelasi constructor ca si superclasa sa.

Contextul în care Enum<E extinde Enum<E>> „Apare este declarația Enum clasa in pachet java.lang :

clasă public abstractă Enum<E extinde Enum<E>> {
  ...
}

Tipul Enum este clasa de bază comună a tuturor tipurilor de enumerare.  În Java, un tip de enumerare, cum ar fi Culoare este tradus într-o clasă Culoare care se extinde Enum<Color> . Scopul superclasei Enum este de a oferi funcționalități comune tutoror tipurilor de enumerare.

Here is o schiță a clasei Enum :

clasă public abstractă Enum< E extinde Enum<E>> implementează Comparable< E >, serializabil {
  nume șir final privat;
  public final String name() { ... }   privat final int ordinal;
  public final int ordinal() { ... }

  protected Enum(Nume șir, ordinal int) { ... }

  public String           toString() { ... }
  public final boolean equals(Object other) { ... }
  public final int hashCode() { ... }
  Obiectul final protejat clone() aruncă CloneNotSupportedException { ... }
  public final int compareTo( E o) { ... }

  finală publică Class< E > getDeclaringClass() { ... }
  public static <T extinde Enum<T>> T valueOf(Class<T> enumType, String name) { ... }
}

Caracteristica surprinzătoare din declarația „ Enum<E extinde Enum<E>> ” is the fact that clasa nouă definită Enum și parametrul de tip nou definit E apar în limita aceluiași parametru de tip.  Înseamnă că Enum tipul trebuie să fie instanțiat pentru unul dintre subtipurile sale.  Pentru a înțelege de ce acest lucru are sens, luați în considerare că fiecare tip de enumerare este tradus într-un subtip de Enum .

Aici este tipul de enumerare artificial Culoare :

enumerare Culoare {ROȘU, ALBASTRU, VERDE}

Compilatorul îl traduce în următoarea clasă:

clasa finală publică Culoare se extinde Enum<Color> {
  public static final Culoare[] values() { return (Culoare[])$VALUES.clone(); }
  public static Culoare valueOf(Nume șir) { ... }   private Culoare(String s, int i) { super(s, i); }

  public static final Culoare ROȘU;
  public static final Culoare ALBASTRU;
  public static final Culoare VERDE;

  privat static final Culoare $VALUES[];

  static {
    ROȘU = Culoare nouă ("ROȘU", 0);
    ALBASTRU = culoare nouă(„ALBASTRU”, 1);
    VERDE = culoare nouă(„VERDE”, 2);
    $VALORI = (Culoare nouă[] { ROȘU, ALBASTRU, VERDE });
  }
}

Moștenirea are ca efect că Culoare type moștenește toate metodele implementate în Enum<Color> .  Printre acestea se numără și compara Cu metodă.  The Culoare. compara Cu metoda ar trebui probabil să ia a Culoare ca argument.  Pentru a face acest lucru să se întâmple clasă Enum este generic și Enum.compareTo metoda ia Enum parametrul de tip al lui E ca argument.  Ca rezultat, tastați Culoare derivat din Enum<Color> moștenește a compara Cu metoda care ia a Culoare ca și argument, exact ca cum ar trevi.
Dacă disecăm declaraia “ Enum<E extinde Enum<E>> „Putem vedea că acest tipar are mai multe aspecte.

În primul rând, există faptul că tipul de parametru legat este tipul în sine: “ Enum <E se extinde Enum <E>> „. Se asigură că numai subtipuri de tip Enum sunt permise ca argumente de tip. (Teoretic, tip Enum ar putea fi instanțiat pe sine, ca în Enum<Enum> )

În al doilei rând, există faptul că tipul legat de parametru este tipul parametrizat Enum <E> , care utilizează parametrul tip E ca argument de tip al legatului. Această declarație se asigură că relația de moștenire dintre un subtip și o instanțiere a Enum este de forma X extinde Enum<X> „. Un subtip precum „ X extinde Enum<Y> ” nu poate fi declarat din cauza argumentului tip Y nu ar fi în limite; numai subtipuri de Enum<X> sunt în limite

În al treilea rând, există faptul că Enum este generic în primul rând.  Înseamnă că unele dintre metodele de clasă Enum ia un argument sau returnează o valoare de tip necunoscut (sau depinde altfel de un tip necunoscut). După cum știm deja, acest tip necunoscut va fi mai târziu un subtip X de Enum<X> .  Prin urmare, în tipul parametrizat Enum<X> , aceste metode implică subtipul X și sunt moștenite în subtip X .  The compara Cu method este un exemplu de souite de method; este moștenit de la superclasă în fiecare subclasă și are o semnătură specifică subclasei în fiecare caz.

Pentru a rezuma, declarația " Enum<E extinde Enum<E>> ” poate fi descifrat ca: Enum este un tip generic care poate fi instanțiat numai pentru subtipurile sale, iar acele subtipuri vor moșteni unele metode utile, unele dintre ele preiau argumente specifice subtipului (sau depind altfel de subtip).

Parametrii de tip limită inferioară ai claselor

Parametrii de tip pot avea mai multe limite, cum ar fi în clasa Box<T extinde Number> {...} . Dar un parametru de tip nu poate avea o limită inferioară, adică un construct precum clasa Box<T mare Număr> {...} nu este permis  De ce nu?  Răspunsul este: este inutil pentru că nu ți-ar comprăto nimic, dacă ar fi permis.  Să vedem de ce parametrii de tip limită inferioară ai claselor sunt confuzi, explorând ce înseamnă o limită superioară a unui parametru de tip.

Limita superioară a unui parametru de tip are trei efecte:

    1. Instanciare restricționată. Limita superioară restricționează setul de tipuri care pot fi utilizate pentru instanțierea tipului generic.  Dacă declarăm a clasa Box<T extinde Number> {...} atunci compilatorul s-ar asigura că numai subtipurile de Număr poate fi folosit ca argument de tip.  Adică a Caseta<Number> sau a Box<Long> este permis, dar a Caseta<Obiect> sau Box<String> ar fi respins

Exemplu (de instanțiere restricționată datorită unei limite superioare a unui parametru de tip):
clasa Box<T extinde Number> { 
   valoarea T privată; 
   public Box(T t) { valoare = t; } 
   ...
}  test de clasa { 
   public static void main(String[] args) { 
       Box<Long> boxOfLong = nou Box<Long>(0L);   // bine
       Box<String> boxOfString = nou Box<String>(""); // eroare: șirul nu este în limite
   }
}

  1. Acces la membrii nestatici. Limita superioară oferă acces la toate metodele și câmpurile publice non-statice ale limitei superioare.  În implementarea noastră clasa Box<T extinde Number> {...} putem invoca toate metodele publice non-statice definite în clasă Număr , ca intValue() de exemplu.  Fără limita superioară, compilatorul ar respinge orice astfel de invocare. Exemplu (de acces la membrii nestatici din cauza unei limite superioare a unui parametru de tip):

clasa Box<T extinde Number> { 
   valoarea T privată; 
   public Box(T t) { valoare = t; } 
   public int increment() { return value.intValue()+1; } // <= ar fi o eroare fără limitarea numărului
   ...
} 

    1. Tip ștergere. Limita superioară din stânga este utilizată pentru ștergerea tipului și înlocuiește parametrul tip din codul octet.  În nostru clasa Box<T extinde Number> {...} toate apariţiile de T ar fi înlocuit cu limita superioară Număr .  De exemplu, dacă clasă Cutie are un câmp privat de tip T si o metoda set gol (conținut T) pentru setarea acestui câmp privat, atunci câmpul ar fi de tip Număr după ștergerea tipului și metoda ar fi tradusă într-o metodă void set (număr conținut) .

Exemplu (de utilizare a limitei superioare pe un parametru de tip în ștergerea tipului – înainte ștergere tip):
clasa Box< T extinde Numărul > { 
   privat T valoare; 
   cutie publica( T t) { valoare = t; } 
   ...
} 

      Exemplu (de utilizare a limitei superioare pe un parametru de tip în ștergerea tipului –

după

      ștergere tip):

 

Class Box { 
   privat Număr valoare; 
   cutie publica( Număr t) { valoare = t; } 
   ...
}

    În plus, limita superioară din stânga apare în alte locații, cum ar fi modelele introduse automat și metodele de punte.

Dacă ar fi permise limite inferioare pentru parametrii de tip, ce efecte secundare ar avea sau ar trebui să aibă? Dacă un construct precum clasa Box<T mare Număr> {...} au fost permis, ce înseamnă?  Ce ar mean cele 3 efecte secundare ale unei limite de parametru de tip superior – instanțiere restricție, acces la un membru non-static, filzere tip – pentru o limită inferioară?

Instanțieri restricționate. Compilatorul ar putea restricționa setul de tipuri care pot fi utilizate pentru instanțierea tipului generic cu un parametru de tip limită inferioară.  De exemplu, compilatorul ar putea permite instanțieri precum Caseta<Number> şi Caseta<Obiect> de la a Box<T mare Număr> și respinge instanțiile precum Box<Long> sau Cutie<Scurt> .  Acesta ar fi un efect în conformitate cu efectul secundar restrictiv descris pentru limitele superioare ale parametrilor de tip.

Acces la membrii nestatici. O limită de parametru de tip inferior nu oferă acces la nicio metodă anume în afara celor moștenite de la clasă Obiect . În exemplul lui Box<T mare Număr> supertipurile de Număr nu au nimic în comun, cu excepția faptului că sunt tipuri de referință și, prin urmare, subtipuri de Obiect .  Compilatorul nu poate presupune că câmpul de tip T este de tip Număr sau un subtip al acestuia.  În schimb, câmpul de tip T poate fi de orice supertip de Număr , ca Serializabil sau Obiect .  Invocarea unei metode precum intValue() nu mai este sigur de tip și compilatorul ar trebui să-l respingă. În consecință, limita parametrului de tip inferior nu ar oferi acces la membrii non-statici dincolo de cei definiți în clasă Obiect și astfel are același efect ca „no bound”.

Tip ștergere .  Urmând această linie de logică, nu are sens să înlocuim aparițiile parametrului tip cu limita inferioară cea mai din stânga.  Declararea unei metode precum constructorul Cutie( T t) ca constructor Cutie( Număr t) nu are sens, având în vedere că T este înlocuit cu un supertip de Număr .  Un Obiect ar putea fi transmis pe bună dreptate constructorului într-o instanțiere Caseta<Obiect> iar constructorul l-ar respinge.  Acest lucru ar fi greșit.   Deci, ștergerea tipului ar înlocui toate aparițiile variabilei tip T după tip Obiect , și nu prin limita sa inferior.  Din nou, limita inferioară ar avea același efect ca „fără limită”.

Vrei să-ți dai seama ce ar mănăi if both sunt mai mici _şi_ au fost permis limită superioară?   Personal, nici nu vreau să mă çordesc la asta și aș prefera să o depun la „ne gestionat” if you allow me.

Concluzia este: tot ce este un “ mare „ bound te-ar cumpăra este restricția pe care numai supertipurile Număr pot fi folosite ca argumente de tip.  Și chiar și asta este adesea înțeles greșit.  NU ar însemna asta clasa Box<T super Number> {...} conține doar exemple de supertipuri de Număr .  Chiar invers – așa cum demonstrează exemplul de mai jos!

Exemplu (de utilizare a limitei superioare pe un parametru de tip în ștergerea tipului – înainte ștergere tip):

clasa Box< T super Număr > {
   privat T valoare;
   cutie publica( T t) { valoare = t; }
   ...
}

Exemplu (de utilizare a limitei superioare pe un parametru de tip în ștergerea tipului – după ștergere tip):

Class Box {
   privat Obiect valoare;
   cutie publica( Obiect t) { valoare = t; }
   ...
}

O clasa Box<T mare Număr> {...} ar fi tradus prin ștergere tip la a Cutie conţinând un Obiect câmp și constructorul său ar fi tradus în Cutie (Obiect t) . Asta este fundamental diferit de a clasa Box<T se extinde Număr> {...} , care s-ar traduce prin a Cutie conţinând a Număr câmp și constructorul său ar fi tradus în Caseta (Numărul t) . În consecință, a Caseta<Number> instanțiat de la a clasa Box<T extinde Number> {...} ar fi diferit de a Caseta<Number> instanțiere de la a clasa Box<T super Number> {...} , ceea ce poate provoca confuzie.  Din acest motiv, limitate inferioare nu au sens pe parametrii de tip ai claselor.

 


 

Parametrii de tip limită inferioară ai metodelor

În combinație cu metodele și tipurile de argumente ale acestora, un parametru de tip cu o limită inferioară poate fi ocazional util.

Exemplu (de method care ar beneficia de un parametru de tip cu o limită inferioară):

clasa Pair<X,Y> {
   privat X mai întâi;
   privat Y secundă;
   ...
   public < Un super X , B super Y > B addToMap(Map<A,B> map) { // eroare: parametrul tip nu poate avea limita inferioară
      return map.put(primul, al doilea);
   }
}
test de clasa { 
   public static void main(String[] args) { 
     Pair<String,Long> pereche = pereche nouă<>(„ABC”,42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Număr număr = pair.addToMap(hartă);
   }
}

The addToMap() metoda adaugă conținutul perechii la o hartă.  Orice hartă care poate conține supertipuri de X şi Y ar face.  Al hărții pune() metoda returnează valoarea găsită în hartă pentru cheia dată, dacă există deja o intrare cheie-valoare pentru cheie în hartă.  Valoarea de returnare a hărții pune() metoda va fi returnată de la addToMap() metodă.  În aceste circumstanțe, ar dori să declarăm metoda așa cum se arată mai sus: Harta este parametrizată cu supertipuri ale parametrilor de tip ai perechii și addToMap() Tipul de returnare al metodei este tipul de valoare al hărții.

Deoarece compilatorul nu permite limite inferioare ale parametrilor de tip, avem nevoie de soluție.

Soluția care îmi vine în minte este folosirea unui wildcard, deoarece metacaracterele pot avea o limită inferioară.  Iată o soluție folosind un wildcard.

Exemplu (de o solution pentru exemplul anterior using metacaracterele):

clasa Pair<X,Y> {
   privat X mai întâi;
   privat Y secundă;
   ...
   public Obiect addToMap(Map< ? Super X , ? super Y Harta >) { 
      return map.put(primul, al doilea);
   }
}
test de clasa { 
   public static void main(String[] args) { 
     Pair<String,Long> pereche = pereche nouă<>(„ABC”,42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Număr număr = (Număr) pair.addToMap(hartă);
   }
}

Funcționează, cu excepția faptului că nu există nicio modalitate de a declara tipul de returnare așa cum se dorește.  Ar fi supertipul de Y pe care compilatorul le captează din tipul hărții, dar nu există o sintaxă pentru a-l specifica.  Nu trebuie să declarăm tipul de returnare „ ? super Y “, pentru că” ? super Y ” este un wildcard și nu un tip și, prin este permis ca tip de returnare. Nu avem de ales și trebuie să folosim Obiect în schimb ca tipul de returnare al metodei noastre.  Acest tip de returnare destul de nespecific forțează, la rândul său, apelanții addToMap() metoda în aruncarea valorii returnate în jos de la Obiect la tipul sau real.  Nu este exact ceea ce aveam în minte.

O altă soluție este utilizarea metodolor statice.  Here is the solution cu o metho statică în loc de o metho non-statică.

Exemplu (de o solution pentru exemplul anterior using o method static):

clasa Pair<X,Y> {
   privat X mai întâi;
   privat Y secundă;
   ...
   public static < O , B ,X extinde A ,Y extinde B > B addToMap(Pair<X,Y> pereche, Map< O , B Harta >) {
      return map.put(pair.first,pair.second);
   }
}
test de clasa { 
   public static void main(String[] args) { 
     Pair<String,Long> pereche = pereche nouă<>(„ABC”,42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Număr număr = Pereche .addToMap( pereche ,hartă);
   }
}

Genericul addToMap() metoda are patru parametri de tip: doi substituenți X şi Y pentru tipul perechii și doi substituenți O şi B pentru tipul hărții. O şi B sunt supertipuri de X şi Y , pentru că X şi Y   sunt declarate cu O şi B ca limitele lor superioare. (Rețineți că parametrii de tip ai metodei generice X şi Y nu au nimic de-a face cu Pereche ale clasei X şi Y parametrii.  Numele X şi Y sunt reutilizate pentru metoda generică pentru a le face easy de recunoscut ca parametri de tip ai perechii. Folosind patru parametri de tip, putem declara tipul de returnare exact după cum se derește: este întotdeauna tip cu tipul de valoare al hărții.

Exemplu (de utilizare illegală a parametrilor tip în context static al unei clase generice):

clasa SomeClass <T> {
  // inițializator static, câmp static, metodă statică
  static {
    SomeClass< T Testul > = SomeClass< nou T >(); // eroare
  }
  privat static T globalInfo;          // eroare
  public  static T getGlobalInfo() {        // eroare
    returnează globalInfo;
  }
  // inițializator non-static, câmp non-static, metodă non-statică
  { 
    SomeClass< T Testul > = SomeClass< nou T >();
  }
  privat        T localInfo;
  public         T getLocalInfo() { 
    returnează localInfo;
  }
  // tipuri imbricate statice
  public static clasă Eșecul extinde excepția {
    finala privata T info;           // eroare
    eșec public ( T t) { info = t; }      // eroare
    public T getInfo() { returnează informații; }    // eroare
   }
  privat interfata Copiabil {
    T copie();                       // eroare
  }
  privat enumerare stat {
    VALID, INVALID;
    privat T info; // eroare
    public void setInfo( T t) { info = t; } // eroare
    public T getInfo() { returnează informații; }    // eroare
  }
  // tipuri imbricate non-statice
  public clasă Accesor {
    public T getInfo() { return localInfo; }
  }
}

Exemplul ilustrează falutto că parameterul tip nu poate fi utilizat în contextul static al unei clase generice.  De asemenea, arată că interfețele imbricate și tipurile de enumerare sunt considerate membri ai tipului și claselor static.  Numai clasele interne, i.e. clasele imbricate non-statice, pot folosi parameterul de tip al clasei generice incluse.

Sfera de aplicare a parametrelui de tip al unei interferențe este definiția completă a interfeței, cu excepții oricăror câmpuri sau tipuri imbricate.  Acest lucru se datorează faptului că câmpurile și tipurile imbricate definite într-o interfață sunt implicite statice.

Exemplu (de utilizare illegală a parametrului tip într-o interfață generică):

interfață SomeInterface <T> {
  // domeniu
  SomeClass< T Valoarea > = SomeClass< nou T >();  // eroare
  // tip imbricat
  clasă Accesor {
    public T getInfo() {            // eroare
      return value.getGlobalInfo();
    }
  }
  // metode
  T getValue();
}

Exemplul arată că câmpurile unei interfețe sunt implicit statice, astfel încât parametrul tip nu poate fi folosit nicăieri în declarația unui câmp al unei interfețe generice.  În mod similar, clasa imbricată este considerată o clasă imbricată statică, nu o clasă interioară și, din acest motiv, utilizarea parametrului tip oriunde în clasa imbricată este ilegală.

Soluție pentru clasele și interfețele statice imbricate:

În cazul claselor și interfețelor imbricate statice, este nu este o calamitate majoră.  Ca o soluție, putem genera clasa statică sau interfața în sine.

Exemplu (soluție – generați de tip static imbricat):

clasa Wrapper <T> {
  finala privata T theObject;

  Wrapper public( T t) { theObject = t; }
  public T getWrapper() { return theObject; }   public Imuabil <T> makeImutable() {
        return new Imutable <T> (Obiectul);
  }
  public Mutabil <T> makeMutable() {
        returnează noul Mutable <T> (Obiectul);
  }
  private static <A> A makeClone(A theObject) { ... }

  public static final class Imuabil <A> { // este o clasă generică acum
        finala privata O theObject;

        public imuabil( O arg) {
            theObject = makeClone(arg);
        }
        public O getWrappedItem() {
            return makeClone(theObject);
        }
  }
  clasă public static Mutable <A> {
        ... asemanator...
  }
}

Nu există o astfel de soluție pentru tipurile de enumerare imbricate, deoarece nu pot fi generice.

Soluție pentru clasele statice imbricate:

If the type static imbricat este o class, o solution alternative ar fi transformarea clasei statice într-o class interiore non-statică.

Exemplu (soluție – use o inner class):

clasa Wrapper <T> {
  finala privata T theObject;

  Wrapper public( T t) { theObject = t; }
  public T getWrapper() { return theObject; }   public Mutable makeMutable() {
      reveni acest. new Mutable(theObject);
  }
  public Imuabil makeImutable() {
      reveni acest. nou Imuabil(theObject);
  }
  private static <A> A makeClone(A theObject) { ... }

  clasă finală publică imuabilă {  // nu mai este o clasă statică
      finala privata T theObject;

      public imuabil( T arg) {
          theObject = makeClone(arg);
      }
      public T getWrappedItem() {
          return makeClone(theObject);
      }
  }
  public class Mutabil 
        ... asemanator...
  }
}

This solution comes with a certain amount of overhead because toate clasele interioare au o reference hidden la o instance de tip exterior, de care în acest exemplu nici nu au nevoie și nici nu profită; the hidden reference is doar bagag  Adesea, clasele interiore sunt combinate cu interfețe pentru a menține clasa interioară un detaliu privat de implementare a clasei incluse.  Putem face același lucru aici.

Exemplu (previous solution a fost rafinat):

clasa Wrapper <T> {
  finala privata T theObject;

  Wrapper public( T t) { theObject = t; }
  public T getWrapper() { return theObject; }   public Mutabil <T> makeMutable() {
      returnează acest lucru.new Mutable(theObject);
  }
  public Imuabil <T> makeImutable() {
      returnează acest lucru.new Immutable(theObject);
  }
  private static <A> A makeClone(A theObject) { ... }

  interfață publică Imuabil<S> {
      S getWrappedItem();
  }
  interfață publică Mutable<S> {
      S getWrappedItem();
      void setWrappedItem(S arg);
  }
  privat clasa finală ImmutableImplementation implementează Immutable<T> { 

      privat final T theObject;

      public ImmutableImplementation(T arg) {
          theObject = makeClone(arg);
      }
      public T getWrappedItem() {
          return makeClone(theObject);
      }
  }
  privat clasa MutableImplementation implementează Mutable<T> { 
        ... asemanator...
  }
}

După cum păută vedea, interfețele publice imbricate trebuie să fie generice, în timp ce clasele private interiore pot folosi parametrul de tip al clasei care se înglobează.

 

 

 

 

 

Lasă un răspuns