Java generika förklaras i kort form med exempel

Se denna FAQ för mer information:

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

Här sammanfattar jag några viktiga punkter från denna FAQ.

Exempel (av en generisk typ):

klass Pair<X,Y> { 
  privat X först;
  privat Y andra;   public Pair(X a1, Y a2) {
    första = al;
    andra = a2;
  }
  public X getFirst() { returnera först; }
  public Y getSecond() { return second; }
  public void setFirst(X arg)  { first = arg; }
  public void setSecond(Y arg) { second = arg; }
}

Klassen Par har två typparametrar X och Y .  De ersätts av typargument när den generiska typen Par är instansierat. Till exempel i deklarationen Pair<String, Date> typparametern X ersätts av typargumentet Sträng och Y ersätts av  Datum .
Omfattningen av identifierarna X och Y är hela definitionen av klassen.  I detta omfång de två typparametrarna X och Y använd som de var typer (med vissa restriktioner). I exemplet ovan används typparametrar som argument och returtyper för instansmetoder och typer av instansfält.
Typparametrar kan deklareras med gränser. Gränser ger tillgång till metoder av den okända typen som typparametern står för. I vårt exempel åberopar vi inte aust metoder av okända typer X och Y . Av denna anledning är två typparametrar begränsade.

Exempel (av en konkret parameteriserad typ):

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

Exempel (på en jokerteckenparameteriserad typ):

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

Alla instansieringar av en generisk typ delar samma runtime-typrepresentation, nämligen representationen av råtypen. Till exempel instansieringar av en generisk typ Lista , som t.ex List<Date> , List<String> , Lista<Long> , etc. har olika statiska typer vid kompilering, men samma dynamiska typ Lista vid körning.

En rollbesättning består av två delar:

  • en statisk typkontroll utförd av kompilatorn vid kompilering och
  • en dynamisk typkontroll utförd av den virtuella maskinen vid körning.

Den statiska delen sorterar bort meningslösa casts, som inte kan lyckas, såsom casten från Sträng att Datum eller från List<String> att List<Date> .

Den dynamiska delen använder runtime-typinformationen och utför en typkontroll vid körning.  Det väcker en ClassCastException om den dynamiska typen av objektet inte är måltypen (eller en undertyp av måltypen) för rollbesättningen. Exempel på casts med en dynamisk del är casten från Objekt att Sträng eller från Objekt att List<String> .  Det är de så kallade downcasts, från en supertyp ner till en subtyp.

Exempel på konkreta parametriserade typer är List<String> , Map<String,Date> , men inte List<? utökar Number> eller Map<String,?> .

Det förväntas att det blir en Lista<Object> skulle vara en supertyp av en List<String> , eftersom Objekt är en supertyp av Sträng .  Denna förväntning härrör från det faktum att en sådan typ av relation finns för arrayer:  Objekt[] är en supertyp av Sträng[] , eftersom Objekt är en supertyp av Sträng . (Denna typ av relation är känd som kovarians .) Super-subtyp-relationen för komponenttyperna sträcker sig till motsvarande arraytyper. Det finns inget sådant typförhållande för instansieringar av generiska typer. (Parameteriserade typer är inte samvariant.)

Avsaknaden av en super-subtyp-relation mellan instansienringar av samma generiska typ har olika konseksiyon.  Här är ett exempel.

Exempel:

void printAll(ArrayList<Object> c) {
  för (Objekt o : c) 
    System.out.println(o);
} ArrayList<String> list = new ArrayList<String>();
... fyll i listan ...
printAll(lista);   // fel

A ArrayList<String> objekt kan inte skickas som argument till en metod som frågar efter en ArrayList<Object> eftersom de två typerna är instansieringar av samma generiska typ, men för olik typargument, och av denna predung är de inte kompatibla med bakaran.

Konkreta parameteriserade typer är konkreta instanzieringar av en generisk typ.  De är nästan som typer; det finns bara ett fåtal limitations.  INTE kan användas för följande ändamål:

  • för att skapa arrayer
  • vid undantagshantering
  • i en klass bokstavlig
  • i en instans av uttryck

Arrayer som konzert element vars typ är en konkret parameteriserad typ är olagliga.

Exempel (på olaglig arraytyp):

static void test() {
  Pair<Integer,Integer>[] intPairArr = ny Par<Integer,Integer>[10] ; // fel
  addElements(intPairArr); 
  Pair<Integer,Integer> par = intPairArr[1];
  Heltal i = pair.getFirst();
  pair.setSecond(i);
}
static void addElements( Objekt[] objArr) {
  objArr[0] = nytt Par<Integer,Integer>(0,0);
  objArr[1] = nytt Pair<String,String>("","");      // bör misslyckas med ArrayStoreException
}

Kompilatorn förbjuder att skapa arrayer vars komponenttyp är en konkret parameteriserad typ, som Par<Integer,Integer> i vårt exempel.  Vi diskuterade i föregående post varför det är rimligt att kompilatorn kvalificerar en Pair<Integer,Integer>[] som olagligt.  Det viktigaste problemet är att kompilatorn och runtime-systemet måste säkerställa att en array är en homogen sekvens av element av samma typ.  En av typkontrollerna, nämligen array-store-checken som utförs av den virtuella maskinen vid körning, misslyckas med att upptäcka den stötande infogningen av ett främmande element. I exemplet den andra infogningen i addElements the metoden skulle misslyckas, since de lade till ett par strängar till en array av integralvärden, men den misslyckas inte som präggat. Skalor som diskuterades i föregående inlägg.

Om du inte kan använda en arrayer som innehåller ett element vars typ är en konkret parameteriserad typ, vad använder du som lösning?

Låt oss överväga tre möjliga lösningar:

  • rad råa typer
  • array av ogränsad jokerteckenparameteriserad typ
  • samling istället för array

Medan uppsättningar av betongparameteriserade typer är olagliga, är samlingar av betongparameteriserade typer tillåtna.

En jokerteckenparameteriserad typ är en instationering av en generisk typ där minst ett typargument är ett jokertecken.  Exempel på parametrisade jokerteckentyper är Samling<?> , List<? utökar Number> , Komparator <? super String> och Par<String,?> . En jokerteckenparametriserad typ betecknar en familj av typer som innefattar konkreta instansieringar av en generisk typ.  Vilken typ av jokertecken som används avgör vilka konkreta parametriserade typer som tillhör familjen.  Till exempel den parametriserade typen med jokertecken Samling<?> betecknar familjen av alla instansieringar av Samling gränssnitt oavsett typargument.  Den parametriserade typen med jokertecken List<? utökar Number> betecknar familjen av alla listtyper där elementtypen är en undertyp av  Antal .  Den parametriserade typen med jokertecken Komparator <? super String> är familjen av alla instansieringar av Komparator gränssnitt för typargumenttyper som är supertyper av Sträng.

En jokerteckenparameteriserad typ är inte en typ i vanlig mening (till skillnad från en icke-parameteriserad klass/gränssnitt eller en råtyp).

Parametriserade jokerteckentyper kan användas för att skriva (som icke-parameteriserade klasser och gränssnitt):

  • som argument och returtyper av metoder
  • som typ av ett fält eller lokal referensvariabel
  • som komponenttyp av ett argument av arrayartyp av andra parametriserade typer
  • som måltyp i kast

Inte bara typer kan vara generiska, utan metoder kan också vara generiska. Statiska och icke-statika metoder samt konstruktörer kan ha typparametar. Syntaxen för deklaration av de formella typparameterna är liknande syntaxen för generiska typer. Typparametersektionen är avgränsad av konkelparenteser och visa för metoders returtyp. Dess syntax och betydelse är identiska med typparameterlistan för en generisk typ.

Här är exemplet på en generisk max metod som beräknar det största värdet i en samling element av en okänd typ A .

Exempel (på en generisk metod):

klasssamlingar {
  offentlig statisk <A förlänger Jämförbar <A>> A max(Collection< A > xs) {
    Iterator< A > xi = xs.iterator();
    A w = xi.next();
    while (xi.hasNext()) {
      A x = xi.next();
      om (w.compareTo(x) < 0) w = x;
    }
    returnera w;
  }
} 

De max metod har en typparameter, namngiven A .  Det är en platshållare för den elementtyp av samlingen som metoden fungerar på. Typparametern har en gräns; det måste vara en typ som är en undertyp av Jämförbar <A>

Exempel (av samma generiska typ, den här gången med gräns):

offentligt gränssnitt Comparable<T> {
  public int compareTo(T arg);
}
offentlig klass TreeMap<Key förlänger Comparable<Key> ,Data>{
  privat statisk klass Entry<K,V> {
     K-nyckel;
     V-värde;
     Entry<K,V> vänster = null;
     Entry<K,V> höger = null;
     Entry<K,V> förälder;
  }
  privat transient Entry<Key,Data> rot = null;
  ...
  private Entry<Key,Data> getEntry(Key key) {
     Entry<Key,Data> p = rot;
     Nyckel k = nyckel;
     while (p != null) {
       int cmp = k. compareTo(p.key) ; 
       if (cmp == 0)
         returnera p;
       annat om (cmp < 0)
         p = p.vänster;
       annan 
         p = p.höger; 
     }
     returnera null;
  }
  public boolean containsKey(Key key) {
     return getEntry(key) != null;
  }
  ...
}

I exemplet ovan, parametern type Nyckel har bunden Jämförbar <Key> .  Specifikation av en gräns har två effekter:

  • Det ger tillgång till de metoder som bunden anger .  I exemplet den bundna Jämförbar <Key> ger tillgång till jämför med metod som vi vill åberopa vid implementeringen av vår Trädkarta klass.
  • Endas typer “inom gränserna” kan användas för instansiering av den generiska typen.   I exemplet kan en parameteriserad typ som t.ex TreeMap<Number,String> skulle avvisas, eftersom typen Antal är inte en undertyp av Jämförbart <Number> .  En parametriserad typ som TreeMap<String,String> skulle accepteras, eftersom typen String är inom gränserna, dvs. är en undertyp av Jämförbar <String> .

Alla klasser, gränssnitt och enumtyper kan användas som typparametrar, inklusive caps och interna typer.  Varken primitiva typer eller arraytyper används som typparameterbunda.

Exempel (på typparametergräns):

klass X0 <T förlängs int > { ... }      // fel
klass X1 <T förlängs Objekt[] > { ... } // fel
klass X2 <T förlängs Antal > { ... }
klass X3 <T förlängs Sträng > { ... }
klass X4 <T förlängs Körbar > { ... }
klass X5 <T förlängs Tråd.Stat > { ... }
klass X6 <T förlängs Lista > { ... }
klass X7 <T förlängs List<String> > { ... }
klass X8 <T förlängs List<? utökar Number> > { ... }
klass X9 <T förlängs Jämförbar <? super Number> > { ... }
klass X10<T förlängs Map.Entry<?,?> > { ... }

Kodexemplet visar att primitiva typer som t.ex int och arraytyper som t.ex Objekt[] är inte pavälände som typparameterbunda.

Klasstyper, som t.ex Antal eller Sträng , och gränssnittstyper, som t.ex Körbar , är tillåtna som typparameterbunda.

Enumtyper, som t.ex Tråd.Stat är också tillåtna som typparameterbundna. Tråd.Stat är ett exempel på en kapslad typ som används som typparameterbunden.  Icke-statiska interna typer är också tillåtna.

Råtyper är persättig som typparameterbunda; Lista är ett exempel.

Parameteriserade typer är tillåtna som typparameterbunda, inklusive konkreta parameteriserade typer som t.ex List<String> , avgränsade jokertecken parametriserade typer som List<? utökar Number> och Jämförbar <? super Long> , och ogränsade jokertecken parametriserade typer som Map.Entry<?,?> .  En gräns som är en parametrisad typ med jokertecken tillåter som typargument alla typer som hör till den typfamilj som jokertecken betecknar.  Den parametrisade jokerteckentypen bunden ger endas gebrättig access till fält och metoder; begränsningar beror på typen av jokertecken.

Exempel (på jokerteckenparameteriserad typ som typparameterbunden):

klass X< T förlänger List<? utökar Number> > {
  public void someMethod(T t) {
    t.add(new Long(0L));    // fel
    Tal n = t.remove(0);
  }
}
klass Test {
  public static void main(String[] args) {
     X<ArrayList< Lång >> x1 = ny X<ArrayList<Long>>(); 
     X<ArrayList< Sträng >> x2 = ny X<ArrayList<String>>(); // fel
  }
}

Referensvariabler av typ T (typparametern) behandlad som referensvariabler av en jokerteckentyp (typparametern bunden).  I vårt exempel är konsektionen att kompilatorn avvisar anrop av metoder som tar ett argument av den “okända” typen som parametern typ står för, som t.ex. Lista.lägg till , eftersom gränsen är en parametrisadar typ med jokertecken med en överre gräns.
Samtidigt det bunda List<? utökar Number> bestämmer vilka typer som kan användas som typargument. Kompilatorn accepterar alla typargument som tillhör typfamiljen List<? utökar Number> , det vill säga alla undertyper av Lista med ett typargument som är en undertyp av Antal .

En typparameter kan användas som gräns för en annan typparameter.

Exempel (på en typparameter som används som en typparameterbunden):

klass Trippel <T> {
  privat T fst, snd, trd;
  offentliga < U förlänger T , V förlänger T , W förlänger T > Trippel(U arg1, V arg2, W arg3) {
    fst = arg1;
    snd = arg2;
    trd = arg3;
  }
}

I det här exemplet är typparametern T av den parametriserade klassen används som bunden av typparametrarna U ,  V och W av en parameteriserad instansmetod av den klassen.

Ytterligare möjligheter att använda typparametrar som gränser för andra typparametrar inkluderar situationer där en sluten typ definieras i en generisk typ eller en lokal klass definieras i en generisk metod.  Det är till och med tillåtet att ochåde en typparameter som bunden av en annan typparameter i samma typparametersektion.

En gräns som är en klass ger tillgång till alla dess publicka-medlemmar, det vill säga publicka fält, metoder och kapslade typer. Endas konstruktörer görs inte überleben, eftersom det inte finns någon garanti för att en subklass av bunden har samma konstruktorer som bunden.

Exempel (på en klass som används som bunden av en typparameter):

offentlig klass Superklass {     // statiska medlemmar
    public enum EnumType {THIS, THAT}
    offentlig statisk Objekt staticField;
    public static void staticMethod() { ... }

    // icke-statiska medlemmar
    offentlig klass InnerClass { ... }
    public Object nonStaticField;
    public void nonStaticMethod() { ... }

    // konstruktörer
    public SuperClass() { ... }

    // privata medlemmar
    privat objekt privat fält; 

    ...
}

offentlig slutklass SomeClass<T förlänger Superklass > {
    privat T-objekt;
    public SomeClass(T t) { objekt = t; } 

    public String toString() {
        återvända
         "statisk kapslad typ    : "+T.EnumType.class+"\n" 
        +"statiskt fält          : "+T.staticField+"\n"
        +"static method         : "+T.staticMethod()+"\n"
        +"icke-statisk kapslad typ: "+T.InnerClass.class+"\n"
        +"icke-statiskt fält      : "+object.nonStaticField+"\n"
        +"non-static method     : "+object.nonStaticMethod()+"\n"
        +"constructor           : "+(ny T())+"\n"                    // fel
        +"privat medlem        : "+object.privateField+"\n"          // fel 
        ;
    }
}

Den bundna Superklass ger tillgång till dess kapslade typer, statiska fält och metoder och icke-statiska fält och metoder.  Endast konstruktören är inte tillgänglig.  Detta beror på att konstruktörer inte ärvs. Varje underklass definierar sina egna konstruktörer och behöver inte stödja sin superklasss konstruktörer.  Därför finns det ingen garanti för att en underklass av Superklass kommer att ha samma konstruktör som sin superklass.

Kontexten i vilket Enum<E förlänger Enum<E>> ” visum är förklaringar från Enum klass i paket java.lang :

offentlig abstrakt klass Enum<E förlänger Enum<E>> {
  ...
}

Typen Enum är den gemensamma basklassen för alla uppräkningstyper.  I Java en uppräkningstyp som t.ex Färg översätts till en klass Färg som sträcker sig Enum<Color> . Syftet med superklassen Enum är att tillhandahålla funktionalitet som är commons för alla uppräkningstyper.

Här är en skiss av klassen Enum :

offentlig abstrakt klass Enum< E förlänger Enum<E>> implementerar Comparable< E >, serialiserbar {
  privat slutlig Strängnamn;
  public final String name() { ... }   privat final int ordinal;
  public final int ordinal() { ... }

  skyddad Enum(Strängnamn, int ordningsföljd) { ... }

  public String           toString() { ... }
  offentlig slutlig boolesk lika med(Objekt annat) { ... }
  public final int hashCode() { ... }
  protected final Object clone() kastar CloneNotSupportedException { ... }
  offentlig final int compareTo( E o) { ... }

  offentlig final Class< E > getDeclaringClass() { ... }
  public static <T utökar Enum<T>> T valueOf(Class<T> enumType, String name) { ... }
}

Det överraskande inslaget i declarationen “ Enum<E förlänger Enum<E>> ” är det faktum att den nydefinierade klassen Enum och dess nydefinierade typparameter E visas i gränsen för samma typparameter.  Det betyder att Enum typ måste instansieras för en av dess undertyper.  För att förstå varför detta är vettigt, tänk på att varje enumtyp översätts till en undertyp av Enum .

Här är den konstruerade enumtypen Färg :

uppräkning Färg {RÖD, BLÅ, GRÖN}

Kompilatorn översätter den till följande klass:

offentlig sista klass Färg sträcker sig Enum<Color> {
  public static final Color[] values() { return (Color[])$VALUES.clone(); }
  public static Color valueOf(String name) { ... }   privat Färg(String s, int i) { super(s, i); }

  offentlig statisk slutlig Färg RÖD;
  offentlig statisk slutlig Färg BLÅ;
  offentlig statisk slutlig Färg GRÖN;

  privat statisk slutlig färg $VALUES[];

  statisk {
    RED = new Color("RED", 0);
    BLÅ = ny färg("BLÅ", 1);
    GRÖN = new Color("GRÖN", 2);
    $VALUES = (ny färg[] { RÖD, BLÅ, GRÖN });
  }
}

Arvet har den effekten att Färg typ ärver alla metoder som implementeras i Enum<Color> .  Bland dem är jämför med metod.  De Färg. jämför med metod bör förmodligen ta en Färg som ett argument.  För att få detta att hända klass Enum är generisk och Enum.compareTo metoden tar Enum s typparameter E som ett argument.  Som ett resultat, skriv Färg härrör från Enum<Color> ärver en jämför med metod som tar en Färg som och argument, precis som det ska.
Om vi ​​​​​​dissekerar declarationen “ Enum<E förlänger Enum<E>> “Vi kan se att det här mönstret har flera aspekter.

För det första är det faktum att typparametern är bunden är själva typen: “ Enum <E förlängs Enum <E>> “. Det ser till att endas subtyper av typ Enum är tillåtna som typargument. (Teoretiskt, typ Enum kan instansieras på sig själv, som i Enum<Enum> , men detta är verkligen inte avsett och det är svårt att föreställa sig en situation där en sådan instans skulle vara användbar.)

För det andra är det faktum att parameterbunden typ är den parameteriserade typen Enum <E> , som använder parametern type E som typargument för bunden. Denna deklaration säkerställer att arvsförhållandet mellan en undertyp och en instansiering av Enum är av formen X förlänger Enum<X> “. En undertyp som “ X förlänger Enum<Y> ” kan inte declareras på grund av typargumentet Y skulle inte vara inom gränserna; endast undertyper av Enum<X> är inom gränsersena.

För det tredje är det factum att Enum är generiskt i första hand.  Det betyder att några av metoderna för klass Enum ta ett argument eller returnera ett värde av en okänd typ (eller på annat sätt bero på en okänd typ). Som vi redan vet kommer denna okända typ senare att bli en undertyp X av Enum<X> .  Alltså i den parametriserade typen Enum<X> , involverar dessa metoder subtypen X , och de ärvs till undertypen X .  De jämför med metod är ett exempel på en sodal metod; den ärvs från superklassen till varje underklass och har en underklassspecifik signatur i varje fall.

För att sammanfatta det, deklarationen “ Enum<E förlänger Enum<E>> ” kan dechiffreras som: Enum är en generisk typ som endast kan instansieras för dess undertyper, och dessa undertyper kommer att ärva några användbara metoder, av vilka några tar undertypsspecifika argument (eller på annat sätt beror på undertypen).

Typparametrar för nedre gräns för klasser

Typparametrar kan ha flera gränser, som i klass Box<T utökar Number> {...} . Men en typparameter kan inte ha någon nedre gräns, det vill säga en konstruktion som t.ex klass Box<T stor Number> {...} är inte tillåtet.  Varför inte?  Svaret är: det är menningslöst eftersom det inte skulle köpa dig något om det var tillåtet.  Låt oss se hårve nedre gräns typparametrar för klasser är förvirrande genom att utforska vad en övre gräns på en typparameter meanner.

Den övre gränsen för en typparameter har tre effekter:

    1. Begränsad instansiering. Den övre gränsen begränsar uppsättningen typer som kan användas för instansiering av den generiska typen.  Om vi ​​deklarerar a klass Box<T utökar Number> {...} då kompilatorn skulle säkerställa att endast undertyper av Antal kan användas som typargument.  Det vill säga a Box<Number> eller a Box<Long> är tillåtet, men a Box<Object> eller Box<String> skulle avvisas

Exempel (på begränsad instansiering på grund av en övre gräns för en typparameter):
klass Box<T utökar Number> { 
   privat T-värde; 
   public Box(T t) { värde = t; } 
   ...
}  klass Test { 
   public static void main(String[] args) { 
       Box<Long> boxOfLong = ny Box<Long>(0L);   //bra
       Box<String> boxOfString = new Box<String>(""); // fel: Strängen är inte inom gränserna
   }
}

  1. Tillgång till icke-statiska medlemmar. Den övre gränsen ger tillgång till alla offentliga icke-statiska metoder och fält för den övre gränsen.  I genomförandet av vår klass Box<T utökar Number> {...} vi kan anropa alla offentliga icke-statiska metoder definierade i klassen Antal , som t.ex intValue() till exempel.  Utan den övre gränsen skulle kompilatorn avvisa varje sådan anrop. Exempel (på tillgång till icke-statiska medlemmar på grund av en övre gräns för en typparameter):

klass Box<T utökar Number> { 
   privat T-värde; 
   public Box(T t) { värde = t; } 
   public int increment() { return value.intValue()+1; } // <= skulle vara ett fel utan numret bundet
   ...
} 

    1. Skriv radering. Den övre gränsen längst till vänster används för typradering och ersätter typparametern i bytekoden.  I vår klass Box<T utökar Number> {...} alla förekomster av T skulle ersättas av den övre gränsen Antal .  Till exempel om klass Låda har ett privat typfält T och en metod void set (T-innehåll) för att ställa in detta privata fält, då skulle fältet vara av typen Antal efter typradering och metoden skulle översättas till en metod void set (nummerinnehåll) .

Exempel (på use av öber gräns på en typparameter vid typradering – före typ radering):
klass Box< T förlänger nummer > { 
   privat T värde; 
   offentlig box( T t) { värde = t; } 
   ...
} 

      Exempel (på use av öber gräns på en typparameter vid typradering –

efter

      typ radering):

 

klass Box { 
   privat Antal värde; 
   offentlig box( Antal t) { värde = t; } 
   ...
}

    Dessutom visas den övre gränsen längst till vänster på ytterligare platser, såsom automatiskt infogade avgjutningar och bryggmetoder.

Om lägre gränser var tillåtna för typparametrar, vilka biverkningar skulle eller borde de ha? Om en konstruktion som t.ex klass Box<T stor Number> {...} var svetni, vad skulle det betyda?  Vad skulle de tre biverkningarna av en överre typparametergräns – restricted instansiering, access till icke-statik medlem, typradering – betyda för en nedre gräns?

Begränsade instansieringar. Kompilatorn skulle kunna begränsa uppsättningen typer som kan användas för instansiering av den generiska typen med en nedre bunden typparameter.  Till exempel kan kompilatorn tillåta instansieringar som t.ex Box<Number> och Box<Object> från a Box<T stor Number> och förkasta instansieringar som t.ex Box<Long> eller Box<Short> .  Detta skulle vara en effekt i linje med den restriktiva sidoeffekt som beskrivs för parametergränser av övre typ.

Tillgång till icke-statiska medlemmar. En lägre typparametergräns ger inte åtkomst till några speciella metoder utöver de som ärvts från klassen Objekt . I exemplet med Box<T stor Number> supertyperna av Antal har inget gemensamt, förutom att de är referenstyper och därför undertyper av Objekt .  Kompilatorn kan inte anta att typfältet T är av typ Antal eller en undertyp därav.  Istället typfältet T kan vara av vilken supertyp som helst Antal , som t.ex Serialiserbar eller Objekt .  Åberopandet av en metod som t.ex intValue() är inte längre typsäker och kompilatorn måste avvisa den. Som en konsekvens skulle den lägre typparametergränsen inte ge åtkomst till icke-statiska medlemmar utöver de som definieras i klassen Objekt och det har samma effekt som “no bound”.

Skriv radering .  Efter denna logik är det inte meningsfullt att ersätta förekomsterna av typparametern med dess nedre gräns längst till vänster.  Deklarerar en metod som konstruktorn Låda( T t) som konstruktör Låda( Antal t) inte vettigt med tanke på det T ersätts av en supertyp av Antal .  En Objekt kan med rätta skickas till konstruktören i en instansiering Box<Object> och konstruktören skulle förkasta det.  Det här vore helt fel.   Så typradering skulle ersätta alla förekomster av typvariabeln T efter typ Objekt , och inte av dess nedre gräns.  Återigen har den nedre gränsen samma effekt som “ingen gräns”.

Vill du lista ut vad det skulle om sänker om botha sänker _och_ var överre gränser södertätt?   Personligen vill jag inte tänka på det och skulle föredra att arkivera det under “ej hanterbart”, om du tillåter.

Summan av kardemumman är: allt det där “ stor “bunden ska köpa dig är den begränsning som bara supertyper av Antal kan användas som typargument.  Och även det missförstås ofta.  Det skulle INTE betyda det klass Box<T super Number> {...} innehåller endast instanser av supertyper av Antal .  Tvärtom – som exemplet nedan visar!

Exempel (på use av öber gräns på en typparameter vid typradering – före typ radering):

klass Box< T supernummer > {
   privat T värde;
   offentlig box( T t) { värde = t; }
   ...
}

Exempel (på use av öber gräns på en typparameter vid typradering – efter typ radering):

klass Box {
   privat Objekt värde;
   offentlig box( Objekt t) { värde = t; }
   ...
}

A klass Box<T stor Number> {...} skulle översättas av typen radering till a Låda innehållande en Objekt fältet och dess konstruktor skulle översättas till Box(Objekt t) . Det är fundamentalt annorlunda än en klass Box<T sträcker sig Number> {...} , som skulle översättas till en Låda innehållande en Antal fältet och dess konstruktor skulle översättas till Ruta (nummer t) . Följaktligen, a Box<Number> instansierat från en klass Box<T utökar Number> {...} skulle vara annorlunda än a Box<Number> instansiering från en klass Box<T super Number> {...} , vilket troligen orsakar förvirring.  Av denna rendezvous är större gränser inte menningsfulla för typparametrar för classer.

 


 

Typparametrar för nedre gräns för metoder

I samband med metoder och deras argumenttyper kan en typparameter med en nedre gräns ibland vara användbar.

Exempel (på en metod som skulle vara användbar med en typparameter med en lägre gräns):

klass Pair<X,Y> {
   privat X först;
   privat Y andra;
   ...
   offentliga < Ett super X , B super Y > B addToMap(Map<A,B> map) { // fel: typparametern kan inte ha lägre gräns
      return map.put(första, andra);
   }
}
klass Test { 
   public static void main(String[] args) { 
     Pair<String,Long> par = new Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Number number = pair.addToMap(map);
   }
}

De addToMap() metod lägger till innehållet i paret till en karta.  Vilken karta som helst som kan hålla supertyper av X och Y skulle göra.  Kartans sätta() metod returnerar värdet som finns i kartan för den givna nyckeln, om det redan finns en nyckel-värde-post för nyckeln i kartan.  Returvärdet för kartans sätta() metod ska returneras från addToMap() metod.  Under dessa omständigheter skulle man vilja deklarera metoden som visas ovan: Kartan parametriseras med supertyper av parets typparametrar och addToMap() methodens returtyp är kartans värdetyp.

Eftersom kompilatorn inte tillåter lägre gränser för typparametrar behöver vi en lösning.

En lösning som kommer att tänka på är användningen av jokertecken, eftersom jokertecken kan ha en lägre gräns.  Här är en lösning med ett jokertecken.

Exempel (på en lösning för föregående exempel med jokertecken):

klass Pair<X,Y> {
   privat X först;
   privat Y andra;
   ...
   offentlig Objekt addToMap(Map< ? Super X , ? super Y > karta) { 
      return map.put(första, andra);
   }
}
klass Test { 
   public static void main(String[] args) { 
     Pair<String,Long> par = new Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Nummer nummer = (Antal) pair.addToMap(karta);
   }
}

Det fungerar, förutom att det inte finns något sätt att deklarera returtypen som önskat.  Det skulle vara supertypen av Y att kompilatorn fangar från karttypen, men det finns ingen syntax för att specificera den.  Vi får inte declarera returtypen som “ ? super Y “, för att” ? super Y ” är ett wildcard och inte en typ och som inte tillåtet som returtyp. Vi har inget val och måste användas Objekt istället som vår metods returtyp.  Denna ganska ospecifika returtyp tvingar i sin tur uppringare av addToMap() metod för att sänka returvärdet från Objekt till dess faktiska typ.  Det var inte precis vad vi hade i åtanke.

En annan lösning är användningen av statistiska metoder.  Här är en lösning med en statisk istället för en icke-statisk metod.

Exempel (på en lösning för föregående exempel med en statisk metod):

klass Pair<X,Y> {
   privat X först;
   privat Y andra;
   ...
   offentlig statisk < A , B ,X förlänger A ,Y förlänger B > B addToMap(Pair<X,Y> par, Map< A , B > karta) {
      return map.put(pair.first,pair.second);
   }
}
klass Test { 
   public static void main(String[] args) { 
     Pair<String,Long> par = new Pair<>("ABC",42L);
     Map<CharSequence, Number> map = HashMap<CharSequence, Number>();
     Nummer nummer = Par .addToMap( par ,karta);
   }
}

Det generiska addToMap() Metoden har fyra typparametrar: två platshållare X och Y för parets typ och två platshållare A och B för kartans typ. A och B är supertyper av X och Y , eftersom X och Y   deklareras med A och B som deras övre gränser. (Observera att den generiska metodens typparametrar X och Y har inget med att göra Par klass X och Y parametrar.  Namnen X och Y ätteranvänds för den generiska metoder för att göra dem lätta att känna igen som parets typparametarar. Med hjälp av fyra typparametrar kan du deklarera den exakta returtypen om så önskas: det är samma typ som värdetypen för kortet.

Exempel (på olaglig ubandung av typparameter i statisk kontext av en generisk klass):

klass SomeClass <T> {
  // statisk initialiserare, statiskt fält, statisk metod
  statisk {
    SomeClass< T >-test = ny SomeClass< T >(); // fel
  }
  privat statisk T globalInfo;          // fel
  offentlig  statisk T getGlobalInfo() {        // fel
    returnera globalInfo;
  }
  // icke-statisk initialiserare, icke-statiskt fält, icke-statisk metod
  { 
    SomeClass< T >-test = ny SomeClass< T >();
  }
  privat        T localInfo;
  offentlig         T getLocalInfo() { 
    returnera localInfo;
  }
  // statiska kapslade typer
  offentlig statisk klass Misslyckande förlänger undantag {
    privat final T info;           // fel
    offentligt misslyckande( T t) { info = t; }      // fel
    offentlig T getInfo() { return info; }    // fel
   }
  privat gränssnitt Kopierbar {
    T kopiera();                       // fel
  }
  privat uppräkning State {
    GILTIGT, OGILTIG;
    privat T info; // fel
    public void setInfo( T t) { info = t; } // fel
    offentlig T getInfo() { return info; }    // fel
  }
  // icke-statiska kapslade typer
  offentlig klass Tillbehör {
    offentlig T getInfo() { return localInfo; }
  }
}

Exempellet illustrerar att typparametern inte kan utnyttjas i det statiska sammanhanget för en generisk klass.  Den visar ökse att kapslade interförde och enumtyper anses vara statiska typer av meldermen i klassen.  Endast inre klasser, det vill säja icke-statica kapslade klasser, kan ausgård typparametern för den omslutande generiska klassen.

Omfattningen av ett interfälts typparameter är hela definitionen av interfältsdeet, except eventualna fält eller kapslade typer.  Detta beror på att fält och kapslade typer som definieras i ett interförde är implicita statiska.

Exempel (om laglig användning av typparametrar i ett generiskt gränssnitt):

gränssnitt SomeInterface <T> {
  // fält
  SomeClass< T >-värde = ny SomeClass< T >();  // fel
  // kapslad typ
  klass Tillbehör {
    offentlig T getInfo() {            // fel
      returnera värde.getGlobalInfo();
    }
  }
  // metoder
  T getValue();
}

Exemplet visar att fält i ett gränssnitt är implicit statiska, så att parametern type inte kan användas någonstans i deklarationen av ett fält i ett generiskt gränssnitt.  På samma sätt anses den kapslade klassen vara en statisk kapslad klass, inte en inre klass, och av denna anledning är användning av parametern type var som helst i den kapslade klassen olaglig.

Lösning för kapslade statiska klasser och gränssnitt:

I fall med statiska kapslade klasser och interförde är detta inte en sökande katastrophe.  Som en lösning kan vi generera den statiska klassen eller självsa entrechtsteet.

Exempel (lösning – generera den kapslade statiska typen):

klass Wrapper <T> {
  privat final T objektet;

  offentligt omslag( T t) { objektet = t; }
  offentlig T getWrapper() { return theObject; }   offentligt oföränderligt <T> makeImmutable() {
        returnera ny oföränderlig <T> (objektet);
  }
  offentlig föränderlig <T> makeMutable() {
        returnera ny Mutable <T> (objektet);
  }
  privat statisk <A> A makeClone(A theObject) { ... }

  offentlig statisk slutklass Oföränderlig <A> { // är en generisk klass nu
        privat final A objektet;

        offentlig oföränderlig( A arg) {
            objektet = makeClone(arg);
        }
        offentlig A getWrappedItem() {
            returnera makeClone(objektet);
        }
  }
  offentlig statisk klass Föränderlig <A> {
        ... liknande ...
  }
}

Det finns ingen sådan lösning för kapslade enumtyper eftersom de inte kan vara generiska.

Lösning för kapslade statiska klasser:

Om den kapslade statiska typen är en klass, skulle en alternativ lösning vara att transformera den statiska klassen till en icke-statik inre klass.

Exempel (lösning – använd i inre klass):

klass Wrapper <T> {
  privat final T objektet;

  offentligt omslag( T t) { objektet = t; }
  offentlig T getWrapper() { return theObject; }   public Mutable makeMutable() {
      återvända detta. new Mutable(theObject);
  }
  public Immutable makeImmutable() {
      återvända detta. new Immutable(theObject);
  }
  privat statisk <A> A makeClone(A theObject) { ... }

  offentlig slutklass Immutable {  // är inte längre en statisk klass
      privat final T objektet;

      offentlig oföränderlig( T arg) {
          objektet = makeClone(arg);
      }
      offentlig T getWrappedItem() {
          returnera makeClone(objektet);
      }
  }
  offentlig klass Föränderlig 
        ... liknande ...
  }
}

Denna lösning kommer med en viss mängd overhead eftersom alla inre klasser har en dolda referens till en instans av den yttre typen, som de i det här exemplet varken behöver eller dra nytta av; den dolda referensen är bara bagage.  Ofta combinas inre klassner med geschäfte för att holli den inre klassen en privat implementationsdetalj av den omslutande klassen.  Vi kan göra samma sak här.

Exempel (de tidigare lösningarna har slutförts):

klass Wrapper <T> {
  privat final T objektet;

  offentligt omslag( T t) { objektet = t; }
  offentlig T getWrapper() { return theObject; }   offentlig föränderlig <T> makeMutable() {
      returnera this.new Mutable(theObject);
  }
  offentligt oföränderligt <T> makeImmutable() {
      returnera this.new Immutable(theObject);
  }
  privat statisk <A> A makeClone(A theObject) { ... }

  offentligt gränssnitt Immutable<S> {
      S getWrappedItem();
  }
  offentligt gränssnitt Föränderlig <S> {
      S getWrappedItem();
      void setWrappedItem(S arg);
  }
  privat slutklass ImmutableImplementation implementerar Immutable<T> { 

      privat final T theObject;

      public ImmutableImplementation(T arg) {
          objektet = makeClone(arg);
      }
      public T getWrappedItem() {
          returnera makeClone(objektet);
      }
  }
  privat klass MutableImplementation implementerar Mutable<T> { 
        ... liknande ...
  }
}

Som du kan se mueste de kapslade publika klassensten vara generiska medan de inre privata klasserna kan objad den omslutande klassens typparameter.

 

 

 

 

 

Lämna ett svar