Java generikk forklart i kort form med eksempler

Se denne vemmele skradn for mer informasjon:

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

Her vil jeg kort lage noen viktige punkter fra denne FAQ.

Eksempel (av en generisk type):

klasse Pair<X,Y> { 
  privat X først;
  private Y andre;   offentlig par(X a1, Y a2) {
    først = a1;
    sekund = a2;
  }
  public X getFirst() { returner først; }
  public Y getSecond() { return second; }
  public void setFirst(X arg)  { first = arg; }
  public void setSecond(Y arg) { second = arg; }
}

Klassen Par har to typeparametere X og Y .  De erstattes av typeargumenter når den generiske typen Par er instansiert. For eksempel i erklæringen Pair<String, Date> typeparameteren X erstattes av type-argumentet String og Y er erstattet av  Dato .
Omfanget av identifikatorene X og Y er hele definisjonen av klassen.  I dette omfanget de to type parametere X og Y brukes som de var typer (med noen mittelunger). I eksemplet ovenfor er typeparameterne som argument- og returtype brukt for forekomstmetoder og typene forekomstfelt.
Typeparametere kan deklareres med kantlinjer. Grenser gir abbing til metoder av den ukjente typen som typeparameteren står for. I vårt njembe bruker vi ingen metoder av ukjent type X og Y . Av denne grunn er de to typeparameterne ubegrensede.

Eksempel (av en konkret parameterisert type):

public void printPair( Par<String,Long> par) {
  System.out.println("("+pair.getFirst()+","+pair.getSecond()+")");
} Par<String,Long> grense = ny Par<String,Long> ("maksimum", 1024L);
printPair(limit);

Eksempel (på en jokertegnsparameterisert type):

public void printPair( Par<?,?> par) {
  System.out.println("("+pair.getFirst()+","+pair.getSecond()+")");
} Par<?,?> grense = ny Par<String,Long> ("maksimum", 1024L);
printPair(limit);

Alle instansiasjoner av en generisk type deler den samme kjøretidstyperepresentasjonen, nemlig representasjonen av råtypen. For eksempel instansiasjoner av en generisk type Liste , som f.eks Liste<Date> , Liste<String> , Liste<Long> , etc. har forskjellige statiske typer ved kompilering, men samme dynamiske type Liste ved kjøretid.

En rollebesetning konsistent av til deler:

  • en statisk typesjekk utført av kompilatoren på kompileringstidspunktet og
  • en dynamisk typesjekk utført av den virtuelle maskinen under kjøring.

Den statiske delen sorterer ut useriøse kast, som ikke kan lykkes, slik som rollebesetningen fra String at Dato eller fra Liste<String> at Liste<Date> .

Den dynamiske delen bruker kjøretidstypeinformasjon og overler og typejekk ved kjøretid.  Det reiser en ClassCastException hvis den dynamiske typen til objektet ikke er måltypen (eller en undertype av måltypen) til rollebesetningen. Eksempler på kast med dynamisk del er rollebesetningen fra Gjenstand at String eller fra Gjenstand at Liste<String> .  Dette er de såkalte downcasts, fra en supertype ned til en undertype.

Eksempler på konkrete parameteriserte typer er Liste<String> , Map<String,Date> , men ikke Liste<? forlenger Number> eller Map<String,?> .

Noen ganger ventet det på en Liste<Object> ville være en supertype av en Liste<String> , fordi Gjenstand er en supertype av String .  Denne forventningen stammer fra det faktum at en slik type forhold eksisterer for matriser:  Gjenstand[] er en supertype av String[] , fordi Gjenstand er en supertype av String . (Denne typen forhold er kjent som kovarians .) Super-subtype-forholdet til komponenttypene strekker seg inn i de tilsvarende array-typene. Det finnes ikke et slikt typeforhold for instansiasjoner av generiske typer. (Parameteriserte typer er ikke kovariant.)

Mangel på super-subtype-forhold mellom forekomster av samme generiske type har forskjellige konsekvenser.  Her er et eksempel.

Eksempel:

void printAll(ArrayList<Object> c) {
  for (Objekt o : c) 
    System.out.println(o);
} ArrayList<String> liste = ny ArrayList<String>();
... fyll listen ...
printAll(liste);   // feil

EN ArrayList<String> objekt kan ikke sendes som argument til en metode som ber om en ArrayList<Object> fordi de to typene er instansiasjoner av samme generiske type, men for forskjellig type arguments, og av denne grunnen er de ikke kompatible med hverandre.

Betongparameteriserte typer er konkrete instansieringer av en generisk type.  De er nesten som typer; det er bare noen få restriksjoner.  Den kan ikke brukes til følgende formål:

  • for å lage matriser
  • i unntakshåndtering
  • i en klasse bokstavelig
  • i en forekomst av uttrykk

Arrays som innholdselementer hvis typen er en konkret parameterisert type er ulovlig.

Eksempel (på ulovlig matrisetype):

static void test() {
  Pair<Integer,Integer>[] intPairArr = ny Par<Heltall,Heltall>[10] ; // feil
  addElements(intPairArr); 
  Pair<Integer,Integer> par = intPairArr[1];
  Heltall i = par.getFirst();
  pair.setSecond(i);
}
static void addElements( Gjenstand[] objArr) {
  objArr[0] = nytt Par<Heltall,Heltall>(0,0);
  objArr[1] = nytt Par<String,String>("","");      // skal mislykkes med ArrayStoreException
}

Kompilatoren forbyr opprettelse av arrays hvis komponenttype er en konkret parameterisert type, som Par<Heltall,Heltall> i vårt eksempel.  Vi diskuterte i forrige oppføring hvorfor det er rimelig at kompilatoren kvalifiserer en Pair<Integer,Integer>[] som ulovlig.  Hovedproblemet er at kompilatoren og kjøretidssystemet må sikre at en matrise er en homogen sekvens av elementer av samme type.  En av typesjekkene, nemlig array-store-sjekken utført av den virtuelle maskinen under kjøring, klarer ikke å oppdage den fornærmende innsettingen av et fremmedelement. I eksemplet den andre innsettingen i addElements metoden skulle mislykkes, fordi de la til et par strenger til en rekke integralverdier, men den mislykkes ikke som forventet. Årsakene ble diskutert i forrige oppføring.

Hvis vi ikke kan bruke arrays som konteer elementer hvis type er en konkret parameterisert type, hva bruker vi som en løsning?

La oss vurdere tre mulige løsninger:

  • rekke råtyper
  • array av ubegrenset jokertegn parameterisert type
  • samling i stedet for array

Mens matriser av betongparametiserte typer er uvoldige, er samlinger av betongparametiserte typer plitti.

En jokertegn-parameteriser type er en instasjonering av en generisk type der minst et type-argument er et jokertegn.  Eksempler på parametriste jokertegntyper er Samling<?> , Liste<? forlenger Number> , Komparator <? super String> og Par<String,?> . En jokertegn-parametrisert type betegner en familie av typer som omfatter konkrete instansieringer av en generisk type.  Hva slags jokertegn som brukes avgjør hvilke konkrete parameteriserte typer som tilhører familien.  For eksempel den parameteriserte jokertegntypen Samling<?> betegner familien til alle instansiasjoner av Samling grensesnitt uavhengig av typeargumentet.  Parameterisert jokertegntype Liste<? forlenger Number> betegner familien til alle listetyper der elementtypen er en undertype av  Tall .  Parameterisert jokertegntype Komparator <? super String> er familien til alle instansiasjoner av Komparator grensesnitt for type argumenttyper som er supertyper av String.

En jokertegn-parameterisert type er ikke en type i vanlig forstand (forskjellig fra en ikke-parameterisert klasse/grensesnitt eller en råtype).

Parametriserte jokertegntyper kan brukes til å skrive (som ikke-parametriserte klasser og grensesnitt):

  • som argument- og returtyper av metoder
  • som type felt eller lokal referansevariabel
  • som komponenttype for et arrayas-argument av andre parameteriserte typer
  • som måltype i kast

Ikke bare typer kan være generiske, men metoder kan ogse være generiske. Statiske og ikke-statiske metoder samt konstruktorer kan ha typeparametere. Syntaksen for deklarasjon av de formelle typeparameterne er lik syntaksen for generiske typer. Typeparameterdelen er avgrenset med konkelparenteser og vises foran metodens returtype. Syntaks og betydninger er identiske med typeparameterlisten for en generisk type.

Her er et eksempel på en generisk måte maks metode som beregner den største verdien i en samling av elementer av en ukjent type EN .

Eksempel (på en generisk metode):

klassesamlinger {
  offentlig statisk <A utvider Sammenlignbar<A>> A max(Samling < EN > xs) {
    Iterator< EN > xi = xs.iterator();
    EN w = xi.neste();
    while (xi.hasNext()) {
      EN x = xi.neste();
      hvis (w.compareTo(x) < 0) w = x;
    }
    returnere w;
  }
} 

De maks metoden har én type parameter, kalt EN .  Det er en plassholder for elementtypen til samlingen som metoden fungerer på. Typeparameteren har en grense; det må være en type som er en undertype av Sammenlignbar <A>

Eksempel (av samme generiske type, denne gangen med grenser):

offentlig grensesnitt Comparable<T> {
  public int compareTo(T arg);
}
offentlig klasse TreeMap<Key forlenger Comparable<Key> ,Data>{
  privat statisk klasse Entry<K,V> {
     K nøkkel;
     V-verdi;
     Entry<K,V> venstre = null;
     Entry<K,V> høyre = null;
     Entry<K,V> forelder;
  }
  privat forbigående Entry<Key,Data> rot = null;
  ...
  private Entry<Key,Data> getEntry(Nøkkelnøkkel) {
     Entry<Key,Data> p = rot;
     Nøkkel k = nøkkel;
     while (p != null) {
       int cmp = k. compareTo(p.key) ; 
       if (cmp == 0)
         retur p;
       annet hvis (cmp < 0)
         p = p.venstre;
       ellers 
         p = p.høyre; 
     }
     returner null;
  }
  public boolean containsKey(Key key) {
     return getEntry(key) != null;
  }
  ...
}

I eksemplet ovenfor, typeparameteren Nøkkel har bundet Sammenlignbar <Key> .  Spesifikasjon av en grense har to effekter:

  • Det gir tilgang til metodene som bindingen spesifiserer .  I eksemplet er bundet Sammenlignbar <Key> gir tilgang til sammenligneTil metode som vi ønsker å påberope oss i implementeringen av vår Trekart klasse.
  • Bare typer “innenfor grensene” kan brukes for instansiering av den generiske typen.   I eksemplet er en parameterisert type som f.eks Trekart<Number,String> ville bli avvist, fordi typen Tall er ikke en undertype av Sammenlignbar <Number> .  En parameterisert type som TreeMap<String,String> ville bli akseptert, fordi typen String er innenfor grensene, dvs. er en undertype av Sammenlignbar <String> .

Alle klasser, grensesnitt og enum-typer kan brukes som typeparameterbundetter, inkludert nestede og indre typer.  Verken primitive typer eller matrisetyper brukes som typeparameterbundet.

Eksempler (på typeparametergrenser):

klasse X0 <T forlenger int > { ... }      // feil
klasse X1 <T forlenger Gjenstand[] > { ... } // feil
klasse X2 <T forlenger Tall > { ... }
klasse X3 <T forlenger String > { ... }
klasse X4 <T forlenger Kjørbar > { ... }
klasse X5 <T forlenger Tråd.Stat > { ... }
klasse X6 <T forlenger Liste > { ... }
klasse X7 <T forlenger Liste<String> > { ... }
klasse X8 <T forlenger Liste<? forlenger Number> > { ... }
klasse X9 <T forlenger Sammenlignbar <? super Number> > { ... }
klasse X10<T forlenger Map.Entry<?,?> > { ... }

Kodeeksemplet viser at primitive typer som f.eks int og matrisetyper som f.eks Gjenstand[] er ikke tillatt som typeparameterbundet.

Klassetyper, som f.eks Tall eller String , og grensesnitttyper, for eksempel Kjørbar , er tillatt noen type parameter bundet.

Enum-typer, som f.eks Tråd.Stat er også tillatt som typeparameterbundet. Tråd.Stat er et eksempel på en nestet type brukt som type parameter bundet.  Ikke-statiske interne typer er også tillatt.

Råtyper er tillate som typeparameterbundet; Liste er et eksempel.

Parameteriserte typer er tillatt som typeparameterbundet, inkludert konkrete parameteriserte typer som e.eks Liste<String> , avgrensede jokertegn parameteriserte typer som Liste<? forlenger Number> og Sammenlignbar <? super Long> , og ubegrensede jokertegn parameteriserte typer som Map.Entry<?,?> .  En grense som er en jokertegn-parameterisert type tillater som typeargument alle typer som tilhører typefamilien som jokertegnet angir.  Jokertegn-parameterisert type bundet gir kun begrenset tilgang til filt og metoder; restriksjonene avhenger av typen jokertegn.

Eksempel (på jokertegnsparameterisert type som typeparameterbundet):

klasse X< T utvider List<? forlenger Number> > {
  public void someMethod(T t) {
    t.add(ny Long(0L));    // feil
    Tall n = t.fjern(0);
  }
}
klasse Test {
  public static void main(String[] args) {
     X<ArrayList< Lang >> x1 = ny X<ArrayList<Long>>(); 
     X<ArrayList< String >> x2 = ny X<ArrayList<String>>(); // feil
  }
}

Referansevariabler av typen T (typeparameteren) behandles som referansevariabler av en jokertegntype (typeparameteren bundet).  I vårt eksempel er konsekvensene ved kompilatoren avviser påkalling av metoder som tar et argument av den “ukjente” typen som typeparameteren står for, som f.eks. Liste.add , fordi grensen er en jokertegn-parameterisert type med en über grensen.
Samtidig det bundne Liste<? forlenger Number> bestemmer typene som kan brukes som typeargumenter. Kompilatoren godtar alle typeargumenter som tilhører typefamilien Liste<? forlenger Number> , det vil si alle undertyper av Liste med et typeargument som er en undertype av Tall .

En typeparameter kan brukes som en grense for en annen typeparameter.

Eksempel (på en typeparameter brukt som en typeparameterbundet):

klasse Trippel <T> {
  privat T fst, snd, trd;
  offentlig < U forlenger T , V forlenger T , W forlenger T > Trippel(U arg1, V arg2, W arg3) {
    fst = arg1;
    snd = arg2;
    trd = arg3;
  }
}

I dette eksemplet er typeparameteren T av den parameteriserte klassen brukes som bundet av typeparameterne U ,  V og W av en parameterisert forekomstmetode av den klassen.

Ytterligere muligheter for å bruke typeparametere som grenser for andre typeparametere inkluderer situasjoner der en nestet type er definert i en generisk type eller en lokal klasse er definert i en generisk metode.  Det er til og med å bruke en typeparameter som bundet av en annen typeparameter i samme typeparameterseksjon.

En grense som er en klasse gir tilgang til alle dens offentlige medlemmer, det vil si offentlig filt, metoder og nestede typer. Bare konstruktorer er ikke gryott tilgjengelig, fordi det ikke er noen garanti for at en underklasse av bundet har de samme konstruktørene som bundet.

Eksempel (på en klasse brukt som bundet av en typeparameter):

offentlig klasse Superklasse {     // statiske medlemmer
    offentlig enum EnumType {THIS, THAT}
    offentlig statisk objekt staticField;
    public static void staticMethod() { ... }

    // ikke-statiske medlemmer
    offentlig klasse InnerClass { ... }
    offentlig objekt nonStaticField;
    public void nonStaticMethod() { ... }

    // konstruktører
    offentlig SuperClass() { ... }

    // private medlemmer
    privat Objekt privatfelt; 

    ...
}

offentlig finaleklasse SomeClass<T forlenger Superklasse > {
    private T objekt;
    public SomeClass(T t) { objekt = t; } 

    public String toString() {
        retur
         "static nested type    : "+T.EnumType.class+"\n" 
        +"static field          : "+T.staticField+"\n"
        +"static method         : "+T.staticMethod()+"\n"
        +"ikke-statisk nestet type: "+T.InnerClass.class+"\n"
        +"non-static field      : "+object.nonStaticField+"\n"
        +"non-static method     : "+object.nonStaticMethod()+"\n"
        +"constructor           : "+(ny T())+"\n"                    // feil
        +"privat medlem        : "+object.privateField+"\n"          // feil 
        ;
    }
}

Det bundne Superklasse gir tilgang til nestede typer, statiske felt og metoder og ikke-statiske felt og metoder.  Bare konstruktøren er ikke tilgjengelig.  Dette er fordi konstruktører ikke er arvet. Hver underklasse definerer sine egne konstruktører og trenger ikke støtte superklassens konstruktører.  Derfor er det ingen garanti for at en underklasse av Superklasse vil ha samme konstruktor som sin superklasse.

Konteksten der Enum<E forlenger Enum<E>> ” vises er avlamentien fra Enum klasse i pakke java.lang :

offentlig abstrakt klasse Enum<E forlenger Enum<E>> {
  ...
}

Typen Enum er den vanlige basisklassen for alle oppregningstyper.  I Java en oppregningstype som f.eks Farge er oversatt til en klasse Farge som strekker seg Enum<Color> . Formålet med superklassen Enum er å gi funksjonalitet som er felles for alle oppregnstyper.

Her er en skisse av klassen Enum :

offentlig abstrakt klasse Enum< E forlenger Enum<E>> implementerer Comparable< E >, serialiserbar {
  privat endelig Strengnavn;
  offentlig endelig strengnavn() { ... }   privat finale int ordinal;
  public final int ordinal() { ... }

  beskyttet Enum(strengnavn, int ordinal) { ... }

  offentlig streng           til String() { ... }
  offentlig endelig boolsk lik(Objekt annet) { ... }
  public final int hashCode() { ... }
  protected final Object clone() kaster CloneNotSupportedException { ... }
  offentlig finale int compareTo( E o) { ... }

  offentlig finale Class< E > getDeclaringClass() { ... }
  offentlig statisk <T utvider Enum<T>> T valueOf(Class<T> enumType, String name) { ... }
}

Den overraskende vandringen og erklæringene “ Enum<E forlenger Enum<E>> ” er det faktum i den nydefinerte klassen Enum og dens nylig definerte typeparameter E vises i grensen for den samme typeparameteren.  Det betyr at Enum type må instansieres for en av undertypene.  For å forstå hvorfor dette er fornuftig, bør du vurdere at hver enum-type er oversatt til en undertype av Enum .

Her er den konstruerte enum-typen Farge :

enum Farge {RØD, BLÅ, GRØNN}

Kompilatoren oversetter det til følgende klasse:

offentlig siste klasse Farge strekker seg Enum<Color> {
  public static final Color[] values() { return (Color[])$VALUES.clone(); }
  offentlig statisk FargeverdiAv(strengnavn) { ... }   privat Farge(streng s, int i) { super(er, i); }

  offentlig statisk endelig Farge RØD;
  offentlig statisk endelig Farge BLÅ;
  offentlig statisk endelig Farge GRØNN;

  privat statisk endelig Farge $VALUES[];

  statisk {
    RØD = ny farge("RØD", 0);
    BLÅ = ny farge("BLÅ", 1);
    GRØNN = ny farge("GRØNN", 2);
    $VALUES = (ny farge[] { RØD, BLÅ, GRØNN });
  }
}

Arven har den virkning at Farge type arver alle metodene implementert i Enum<Color> .  Blant dem er sammenligneTil metode.  De Farge. sammenligneTil metode bør trolig ta en Farge som et argument.  For å få dette til å skje klasse Enum er generisk og Enum.compareTo metoden tar Enum ‘s typeparameter E som et argument.  Som et resultat, skriv Farge avledet fra Enum<Color> arver en sammenligneTil metode som tar en Farge som og argument, akkurat som det skal.
Hvis vi dissekerer oblavanienen “ Enum<E forlenger Enum<E>> “Vi kan se at dette tpsonnet har flere aspekter.

For det første er det faktum at typeparameteren bundet er selve typen: “ Enum <E forlenges Enum <E>> “. Det sørger for at bare subtyper av type Enum er tillatt som typeargumenter. (Teoretisk sett, skriv Enum kan instansieres på seg selv, som i Enum<Enum> , men dette er absolutt ikke ment, og det er dilfiksi å imieve seg en sitzung der en slik instasiering ville være utilität.)

For det andre er det faktum at parameterbundet type er den parameteriserte typen Enum <E> , som bruker typeparameteren E som typeargumentet til bundet. Denne erklæringen sørger for at arveforholdet mellom en undertype og en instansiering av Enum er av formen X forlenger Enum<X> “. En undertype som “ X forlenger Enum<Y> ” kan ikke declarares på grunt av typeargumentet Y ville ikke være innenfor grensene; bare undertyper av Enum<X> er innenre grensene.

For det tredje er det det factum at Enum er generisk i utgangspunktet.  Det betyr at noen av metodene i klassen Enum ta et argument eller returner en verdi av en ukjent type (eller på annen måte avhengig av en ukjent type). Som vi allerede vet, vil denne ukjente typen senere være en undertype X av Enum<X> .  Derfor, i den parameteriserte typen Enum<X> , involverer disse metodene undertypen X , og de arves inn i undertypen X .  De sammenligneTil metode er et eksempel på en slik metode; den arves fra superklassen til hver underklasse og har en underklassespezifik signatur i hvert tilfelle.

For å oppsummere, erklæringer “ Enum<E forlenger Enum<E>> ” kan vise som: Enum er en generisk type som bare kan instansieres for undertypene, og disse undertypene vil arve noen nyttige metoder, hvorav noen tar undertypespesifikke argumenter (eller på annen måte avhenger av undertypen).

Nedre grensetypeparametere for klasser

Typeparametere kan ha flere grenser, som i klasse Box<T utvider Number> {...} . Men en typeparameter kan ikke ha noen nedre grense, det vil si en konstruksjon som f.eks klasse Box<T stor Number> {...} det er ikke tillatt  Hvorfor ikke?  Svaret er: det er menningsløst fordi det ikke ville kjøpe deg noe hvis det var tillatt.  La oss se hovorn nedre grensetypeparametere for classer er forvirrende ved å utforske hva en über grense på en typeparameter meanter.

Den øvre grensen på en typeparameter har tre effekter:

    1. Begrenset instansiering. Den øvre grensen begrenser settet med typer som kan brukes for instansiering av den generiske typen.  Hvis vi erklærer en klasse Box<T utvider Number> {...} så vil kompilatoren sikre at bare undertyper av Tall kan brukes som type argument.  Det vil si a Box<Number> eller a Box<Long> er tillatt, men a Box<Object> eller Box<String> ville bli avvist

Eksempel (på begrenset instansiering på grunn av en øvre grense for en typeparameter):
klasse Box<T utvider Number> { 
   privat T-verdi; 
   offentlig boks(T t) { verdi = t; } 
   ...
}  klasse Test { 
   public static void main(String[] args) { 
       Box<Long> boxOfLong = ny Box<Long>(0L);   // greit
       Box<String> boxOfString = ny Box<String>(""); // feil: Strengen er ikke innenfor grensene
   }
}

  1. Tilgang til ikke-statiske medlemmer. Den øvre grensen gir tilgang til alle offentlige ikke-statiske metoder og felt i den øvre grensen.  I gjennomføringen av vår klasse Box<T utvider Number> {...} vi kan påkalle alle offentlige ikke-statiske metoder definert i klassen Tall , som f.eks intValue() for eksempel.  Uten den øvre grensen ville kompilatoren avvise enhver slik påkallelse. Eksempel (på tilgang til ikke-statiske medlemmer på grunn av en øvre grense på en typeparameter):

klasse Box<T utvider Number> { 
   privat T-verdi; 
   offentlig boks(T t) { verdi = t; } 
   public int increment() { return value.intValue()+1; } // <= ville være en feil uten nummeret bundet
   ...
} 

    1. Skriv sletting. Den øvre grensen lengst til venstre brukes for typesletting og erstatter typeparameteren i bytekoden.  I vår klasse Box<T utvider Number> {...} alle forekomster av T ville bli erstattet av den øvre grensen Tall .  For eksempel hvis klasse Eske har et privat type felt T og en metode void sett (T innhold) for å angi dette private feltet, vil feltet være av typen Tall etter type sletting og metoden vil bli oversatt til en metode void set (nummerinnhold) .

Eksempel (på bruk av øvre grense på en typeparameter i typeletting – før type sletting):
klasse Box< T utvider nummer > { 
   privat T verdi; 
   offentlig boks( T t) { verdi = t; } 
   ...
} 

      Eksempel (på bruk av øvre grense på en typeparameter i typeletting –

etter

      type sletting):

 

klasse Box { 
   privat Tall verdi; 
   offentlig boks( Tall t) { verdi = t; } 
   ...
}

    I tillegg vises den øvre grensen lengst til venstre på andre steder, for eksempel automatisk innsatte kast og brometoder.

Hvis nedre grenser var tillatt for typeparametere, hvilke bivirkninger ville eller burde de ha? Hvis en konstruksjon som f.eks klasse Box<T stor Number> {...} var pröti, hva ville det bety?  Hva vil de tre bivirkningene av en øvre type parametergrense – begrenset installasjon, tilgang til ikke-statisk medlem, type sletting – bety for en nedre grense?

Begrensede instansiasjoner. Kompilatoren kan begrense settet med typer som kan brukes for instansiering av den generiske typen med en nedre grensetypeparameter.  For eksempel kan kompilatoren tillate instansiasjoner som f.eks Box<Number> og Box<Object> fra a Box<T stor Number> og avvise instansiasjoner som f.eks Box<Long> eller Box<Short> .  Dette vil være en effekt i tråd med den restriktive bivirkningen beskrevet for øvre type parametergrenser.

Tilgang til ikke-statiske medlemmer. En lavere type parametergrense gir ikke tilgang til noen spesielle metoder utover de som er arvet fra klassen Gjenstand . I eksemplet med Box<T stor Number> supertypene av Tall har ingenting til felles, bortsett fra at de er referansetyper og derfor undertyper av Gjenstand .  Kompilatoren kan ikke anta at feltet type T er av typen Tall eller en undertype derav.  I stedet feltet for type T kan være av hvilken som helst supertype Tall , som f.eks Serialiserbar eller Gjenstand .  Påkallelsen av en metode som f.eks intValue() er ikke lenger typesikker og kompilatoren må avvise den. Som en konsekvens vil den nedre typeparametergrensen ikke gi tilgang til et ikke-statisk medlem utover de som er definert i klassen Gjenstand og har dermed samme effekt som “no bound”.

Skriv Sletting .  Etter denne logikken gir det ikke mening å erstatte forekomstene av typeparameteren med dens nedre grense lengst til venstre.  Erklære en metode som konstruktøren Eske( T t) som konstruktør Eske( Tall t) gir ikke mening, med tanke på det T er erstattet av en supertype av Tall .  An Gjenstand kan med rette sendes til konstruktøren på en gang Box<Object> og konstruktøren ville avvise det.  Dette ville vært helt feil.   Så, type sletting ville erstatte alle forekomster av typevariabelen T etter type Gjenstand , og ikke ved sin nedre grense.  Igjen vil den nedre grensen har samme effekt som “ingen grense”.

Vil du finne ut hva det ville bety om begge lavere _og_ var über grenser permitti?   Personlig vil jeg ikke engang tenke på det og preferer å arkivere det under “ikke hänterbart”, hvis du limoor det.

Hovedpoenget er: alt det en “ stor ” bundet ville kjøpe deg er kommettelien som bare supertyper av Tall kan brukes som typeargumenter.  Og selv det blir ofte misforstått.  Det vil IKKE bety det klasse Box<T super Number> {...} inneholder bare forekomster av supertyper av Tall .  Tvert imot – som eksempel nedenfor viser!

Eksempel (på bruk av øvre grense på en typeparameter i typeletting – før type sletting):

klasse Box< T supernummer > {
   privat T verdi;
   offentlig boks( T t) { verdi = t; }
   ...
}

Eksempel (på bruk av øvre grense på en typeparameter i typeletting – etter type sletting):

klasse Box {
   privat Gjenstand verdi;
   offentlig boks( Gjenstand t) { verdi = t; }
   ...
}

EN klasse Box<T stor Number> {...} ville bli oversatt med type sletting til a Eske som inneholder en Gjenstand felt og dets konstruktør ville bli oversatt til Boks(objekt t) . Det er fundamentalt forskjellig fra en klasse Box<T strekker seg Number> {...} , som vil bli oversatt til en Eske som inneholder en Tall felt og dets konstruktør ville bli oversatt til Boks (nummer t) . Følgelig, a Box<Number> instansiert fra en klasse Box<T utvider Number> {...} ville være annerledes enn en Box<Number> instansiasjon fra en klasse Box<T super Number> {...} , som sannsynligvis vil forårsake forvirring.  Av denne grunn gir ikke nedre grenser mening for typeparametere for classer.

 


 

Nedre grense Type parametere for metoder

Jeg tar kontakt med metoder og deres argumenttyper kan en typeparameter med en nedre grense av og til å være utilität.

Eksempel (på en metode som vil ha nytte av en typeparameter med en nedre grense):

klasse Pair<X,Y> {
   privat X først;
   private Y andre;
   ...
   offentlig < En super X , B super Y > B addToMap(Map<A,B> map) { // feil: type parameter kan ikke ha nedre grense
      return map.put(første, andre);
   }
}
klasse Test { 
   public static void main(String[] args) { 
     Pair<String,Long> par = nytt Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Tallnummer = par.addToMap(map);
   }
}

De addToMap() metoden legger til innholdet i paret til et kart.  Ethvert kart som kan inneholde supertyper av X og Y ville gjøre.  Kartet er sette() metoden returnerer verdien funnet i kartet for den gitte nøkkelen, hvis det allerede er en nøkkelverdioppføring for nøkkelen i kartet.  Returverdien til kartets sette() metoden skal returneres fra addToMap() metode.  Under disse omstendighetene vil man gjerne deklarere metoden som vist ovenfor: Kartet er parameterisert med supertyper av parets typeparametere og addToMap() methodens returtype er kartets verditype.

Siden kompilatoren ikke er på nedre grenser for typeparametere, tregn vi en løsning.

En løsen som kommer til tankene er bruken av et jokertegn, fordi jokertegn kan ha en nedre grense.  Her er en løsen med et jokertegn.

Eksempel (på en løsning for forrige eksempel ved bruk av jokertegn):

klasse Pair<X,Y> {
   privat X først;
   private Y andre;
   ...
   offentlig Gjenstand addToMap(Map< ? Super X , ? super Y > kart) { 
      return map.put(første, andre);
   }
}
klasse Test { 
   public static void main(String[] args) { 
     Pair<String,Long> par = nytt Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Tall nummer = (Tall) pair.addToMap(kart);
   }
}

Det fungerer, bortsett fra at det ikke er mulig å deklarere returtypen som ønsket.  Det ville være supertypen av Y at kompilatoren fanger opp fra karttypen, men det er ingen syntaks for å spesifisere den.  Vi må ikke deklarere returtypen som “ ? super Y “, fordi ” ? super Y ” er et jokertegn og ikke en type og er derfer ikke på som returtype. Vi har ikke noe valg og må bruke Gjenstand i stedet som vår metodes returtype.  Denne ganske uspesifikke returtypen tvinger igjen oppringere av addToMap() metode til å kaste returverdien ned fra Gjenstand til synd faktisk type.  Dette var ikke nøyaktig det vi hadde i tankene.

En annen løsning er å bruke statiske metoder.  Her er en løsning med en statisk i stedet for en ikke-statisk metode.

Eksempel (på en omveining for forrige eksempel ved bruk av en statisk metode):

klasse Pair<X,Y> {
   privat X først;
   private Y andre;
   ...
   offentlig statisk < EN , B ,X forlenger A ,Y forlenger B > B addToMap(Pair<X,Y> par, Map< EN , B > kart) {
      return map.put(pair.first,pair.second);
   }
}
klasse Test { 
   public static void main(String[] args) { 
     Pair<String,Long> par = nytt Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Tall nummer = Par .addToMap( par ,kart);
   }
}

Det generiske addToMap() metoden har fire typeparametere: to plassholdere X og Y for parets type og to plassholdere EN og B for karttypen. EN og B er supertyper av X og Y , fordi X og Y   er erklært med EN og B som deres øvre grenser. (Merk at den generiske metodens typeparametere X og Y har ingenting med det å gjøre Par klasses X og Y parametere.  Navnene X og Y bli gjenbrukt for den generiske methoden for å gjøre dem lett gjenkjennelige som parets typeparametere. Ved å bruke fire typeparametere kan vi deklarere den nøyaktige returtypen etter wörne: det er samme type som verditypen på kartet.

Eksempel (på ulovlig bruk av typeparameter i statisk kontekst av en generisk klasse):

klasse SomeClass <T> {
  // statisk initialisering, statisk felt, statisk metode
  statisk {
    NoenClass< T > test = ny SomeClass< T >(); // feil
  }
  privat statisk T globalInfo;          // feil
  offentlig  statisk T getGlobalInfo() {        // feil
    returnere globalInfo;
  }
  // ikke-statisk initialisering, ikke-statisk felt, ikke-statisk metode
  { 
    NoenClass< T > test = ny SomeClass< T >();
  }
  privat        T lokalInfo;
  offentlig         T getLocalInfo() { 
    returner lokalInfo;
  }
  // statiske nestede typer
  offentlig statisk klasse Feil utvider unntak {
    privat finale T info;           // feil
    offentlig feil( T t) { info = t; }      // feil
    offentlig T getInfo() { return info; }    // feil
   }
  privat grensesnitt Kopierbar {
    T kopiere();                       // feil
  }
  privat enum Delstat {
    GYLDIG, UGYLDIG;
    privat T info; // feil
    offentlig void setInfo( T t) { info = t; } // feil
    offentlig T getInfo() { return info; }    // feil
  }
  // ikke-statiske nestede typer
  offentlig klasse Tilbehør {
    offentlig T getInfo() { return localInfo; }
  }
}

Eksemplet illustrarer at typeparameteren kan ikke ellers i den statiske konteksten til en generisk klasse.  Den viser ogssa at nestede og enumtyper anses som statice members av klassen.  Bare indre klasser, det vil si ikke-statice nestede klasser, kan bruke typeparameteren til den omsluttende generiske klassen.

Omfanget av grensesnitttypeparameteren er hele definisjonen av grensesnittet, bortsett fra mulig filt eller nestet type.  Dette er fordi felt og nestede typer definit i et entrechts implisitt er statiske.

Eksempel (på ulovlig bruk av typeparameter og generisk grensesnitt):

grensesnitt SomeInterface <T> {
  // felt
  NoenClass< T >-verdi = ny SomeClass< T >();  // feil
  // nestet type
  klasse Tilbehør {
    offentlig T getInfo() {            // feil
      returner verdi.getGlobalInfo();
    }
  }
  // metoder
  T getValue();
}

Eksemplet viser at felt i et grensesnitt implisitt er statiske, slik at typeparameteren ikke kan brukes noe sted i deklarasjonen av et felt i et generisk grensesnitt.  På samme måte betraktes den nestede klassen som en statisk nestet klasse, ikke en indre klasse, og av denne grunn er bruk av typeparameteren hvor som helst i den nestede klassen ulovlig.

Løsning for nestede statiske klasser og grensesnitt:

I case av statiske nestede klasser og entrechts er ikke dette en stor ulkeli.  Som en løsen kan vi generere den statiske klassen eller aussettet selv.

Eksempel (løsning – generer den stede statiske typen):

klasse wrapper <T> {
  privat finale T objektet;

  offentlig innpakning( T t) { objektet = t; }
  offentlig T getWrapper() { return theObject; }   offentlig uforanderlig <T> makeImmutable() {
        returner ny uforanderlig <T> (objektet);
  }
  offentlig Foranderlig <T> makeMutable() {
        returner ny Mutable <T> (objektet);
  }
  privat statisk <A> A makeClone(A theObject) { ... }

  offentlig statisk sluttklasse Uforanderlig <A> { // er en generisk klasse nå
        privat finale EN objektet;

        offentlig uforanderlig( EN arg) {
            objektet = makeClone(arg);
        }
        offentlig EN getWrappedItem() {
            return makeClone(objektet);
        }
  }
  offentlig statisk klasse Mulig <A> {
        ... lignende ...
  }
}

Det er ingen slik løsning for nestede enum-typer fordi de ikke kan være generiske.

Løsning for nestede statiske klasser:

Hvis den nestede statiske typen er en klasse, vil en alternativ løsning være å gjøre den statiske klassen til en ikke-statisk indre klasse.

Eksempel (løsning – bruk en indre klasse):

klasse wrapper <T> {
  privat finale T objektet;

  offentlig innpakning( T t) { objektet = t; }
  offentlig T getWrapper() { return theObject; }   public Mutable makeMutable() {
      retur dette. ny Mutable(objektet);
  }
  public Immutable makeImmutable() {
      retur dette. ny uforanderlig(objektet);
  }
  privat statisk <A> A makeClone(A theObject) { ... }

  offentlig siste klasse uforanderlig {  // er ikke lenger en statisk klasse
      privat finale T objektet;

      offentlig uforanderlig( T arg) {
          objektet = makeClone(arg);
      }
      offentlig T getWrappedItem() {
          return makeClone(objektet);
      }
  }
  offentlig klasse Mulig 
        ... lignende ...
  }
}

Denne løsningen kommer med en viss mengde overhead fordi alle indre klasser har en scudt reference til en instans av den ytre typen, som de i dette eksemplet verken tregn eller utilizator; de skjulte referansene er bare bagasje.  Ofte kombineres indre klasser med erfellt for å holde den indre klassen en privat implementeringsdetalj av den omsluttende klassen.  Vi kan gjøre det samme her.

Eksempel (den forrige løsningen er avgrenset):

klasse wrapper <T> {
  privat finale T objektet;

  offentlig innpakning( T t) { objektet = t; }
  offentlig T getWrapper() { return theObject; }   offentlig Foranderlig <T> makeMutable() {
      return this.new Mutable(theObject);
  }
  offentlig uforanderlig <T> makeImmutable() {
      return this.new Immutable(theObject);
  }
  privat statisk <A> A makeClone(A theObject) { ... }

  offentlig grensesnitt Immutable<S> {
      S getWrappedItem();
  }
  offentlig grensesnitt Mutable<S> {
      S getWrappedItem();
      void setWrappedItem(S arg);
  }
  privat siste klasse ImmutableImplementation implementerer Immutable<T> { 

      privat finale T objektet;

      public ImmutableImplementation(T arg) {
          objektet = makeClone(arg);
      }
      public T getWrappedItem() {
          return makeClone(objektet);
      }
  }
  privat klasse MutableImplementation implementerer Mutable<T> { 
        ... lignende ...
  }
}

Som du kan se, må de nestede offentlige entrechtene være generiske, mens de indre private klassene kan bruke den omsluttende klassens typeparameter.

 

 

 

 

 

Legg igjen et svar