Java generika vysvětlená v krátké formě s příklady

Další informace naleznete v tomto FAQ:

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

Zde ve zkratce některé důležité orgány z tohoto FAQ.

Příklad (obecného typu):

třída Pair<X,Y> { 
  soukromé X první;
  soukromá Y sekunda;   public Pair(X a1, Y a2) {
    první = a1;
    druhý = a2;
  }
  public X getFirst() { return first; }
  public Y getSecond() { return second; }
  public void setFirst(X arg)  { first = arg; }
  public void setSecond(Y arg) { sekunda = arg; }
}

Třída Pár má dva parametry typu X a Y .  Při generickém typu jsou nahrazeny argumenty typu Pár je vytvořena instance. Například v prohlášení Pair<String, Date> parametr typu X je nahrazen argumentem typu Řetězec a Y je nahrazeno  Datum .
Identifikátory X a Y je celou definici třídy.  V tomto rozsahu dva parametry typu X a Y se používají jako by byly typy (s určitými omezeními). Ve výše uvedeném příkladu jsou parametry typu použity jako argument pro instanci metody návratového typu a instanci typy polí.
Parametry typu lze deklarovat s mezemi. Nabídka umožňuje přístup k metodám neznámého typu, který představuje typ parametru. V našem příkladu jsme nevolali žádné metody neznámého typu X a Y . Z tohoto důvodu jsou zde pouze dva parametry.

Příklad (konkrétního parametrizovaného typu):

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

Příklad (zástupného parametrizovaného typu):

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

Všechny instance obecného typu sdílejí stejnou reprezentaci runtime typu, konkrétně reprezentaci nezpracovaného typu. Například konkretizace obecného typu Seznam , jako např Seznam<Datum> , Seznam<String> , List<Long> , atd. mají různé statické typy v době kompilace, ale stejný dynamický typ Seznam pro běhání.

Casting se skládá ze dvou částí:

  • statická kontrola typu prováděná kompilátorem v době kompilace a
  • dynamická kontrola typu prováděná virtuálním počítačem za běhu.

Statická část vytřídí nesmyslná obsazení, která nemohou uspět, jako například obsazení z Řetězec že Datum nebo od Seznam<String> že Seznam<Datum> .

Dynamická část využívá informace o typu běhu a provádí řízení typu běhu.  Seštuje a ClassCastException pokud dynamický typ objektu není cílovým typem (nebo podtypem cílového typu) přetypování. Příklady odlitků s dynamickou částí jsou odlitky z Objekt že Řetězec nebo od Objekt že Seznam<String> .  Jedná se o tzv. downcasty, od supertypu po podtyp.

Příklady konkrétních parametrizovaných typů jsou jso Seznam<String> , Mapa<String,Datum> , ale ne List<? rozšiřuje Číslo> nebo Mapa<String,?> .

Někdy se očekává, že a Seznam<OObjekt> by byl supertypem a Seznam<String> , protože Objekt je supertypem Řetězec .  Toto očekávání vychází ze skutečnosti, že takový typ vztahu existuje pro pole:  Objekt[] je supertypem řetězec[] , protože Objekt je supertypem Řetězec . (Tento typ vztahu je známý jako kovariance .) Vztah superpodtypů typů komponent se rozšiřuje do odpovídajících typů polí. Žádný takový vztah typu neexistuje pro konkretizace generických typů. (Parametrizované typy jsou ne kovariantní.)

Absence vztahu mezi podtypy mezi instancemi stejného generického typu má různé důsledky.  Zde je příklad.

Příklad:

void printAll(ArrayList<Object> c) {
  pro (Objekt o: c) 
    System.out.println(o);
} ArrayList<String> seznam = new ArrayList<String>();
... vyplnit seznam ...
printAll(seznam);   // chyba

A ArrayList<String> objekt nelze předat jako argument metodě, která požaduje a ArrayList<Oobject> protože tyto dva typy jsou instancemi stejného obecného typu, ale pro jiný argumenty typu a ze svetto svetnogo nejsou vzájemně kompatibilní.

Kontekstní parametrizované typy jsou konkretizace konkretizace objektu typu.  Jsou skoro jako typy; existuje několik omezení.  NELZE se používá pro následující účely:

  • pro vytváření polí
  • při zpracování výjimek
  • ve třídním doslovu
  • v an instanceof výraz

Sloupy držící prvky, jejichž typ je konkrétně parametrizován, jsou nezákonné.

Příklad (nelegální tyč typu):

static void test() {
  Pair<Integer,Integer>[] intPairArr = nový Pár<Integer,Integer>[10] ; // chyba
  addElements(intPairArr); 
  Pair<Integer,Integer> pair = intPairArr[1];
  Celé číslo i = pair.getFirst();
  pair.setSecond(i);
}
statické void addElements( Objekt[] objArr) {
  objArr[0] = new Pair<Integer,Integer>(0,0);
  objArr[1] = nový Pair<String,String>("","");      // by měl selhat s ArrayStoreException
}

Kompilátor zakazuje vytváření polí, jejichž typ komponenty je konkrétní parametrizovaný typ, např Pair<Integer,Integer> v našem příkladu.  V předchozím záznamu jsme diskutovali, proč je rozumné, aby kompilátor kvalifikoval a Pair<Integer,Integer>[] jako nelegální.  Klíčovým problémem je, že kompilátor a runtime systém musí zajistit, že pole je a homogenní posloupnost prvků stejného typu.  Jedna z typových kontrol, konkrétně kontrola pole-store-check prováděná virtuálním strojem za běhu, nedokáže detekovat problematické vložení cizího prvku. V příkladu druhé vložení do addElements metoda by měla selhat, čerceva předavali pár četűců do pole integrálních ródő, ale neselže podle sztečného. Důvody byly diskutovány v předchozím příspěvku.

Pokud nemůžete použít pole obsahující prvky, jejichž typ je specifický parametrizovaný typ, co použijete jako řešení?

Zvažme 3 mystelná řešení:

  • řada syrových typů
  • pole neomezeného zástupného parametrizovaného typu
  • kolekce místo pole

Zatímco pole konkrétních parametrizovaných typů jsou nelegální, kolekce konkrétních parametrizovaných typů jsou povoleny.

Zástupný parametrizovaný typ je instancí obecného typu, kde alespoň jeden typ argumentu je reprezentativní znak.  Příklady parametrizovaných typů jsou reprezentativní Kolekce<?> , List<? rozšiřuje Číslo> , Srovnávač<? Super String> a Pair<String,?> . Zástupný parametrizovaný typ označuje rodinu typů obsahující konkrétní konkretizace obecného typu.  Druh použitého zástupného znaku určuje, které konkrétní parametrizované typy patří do rodiny.  Například parametrizovaný typ zástupného znaku Kolekce<?> označuje rodinu všech instancí Sbírka rozhraní bez ohledu na argument typu.  Zástupný parametrizovaný typ List<? rozšiřuje Číslo> označuje rodinu všech typů seznamů, kde je typ prvku podtypem  Číslo .  Zástupný parametrizovaný typ Srovnávač<? Super String> je rodina všech instancí Komparátor rozhraní pro typy argumentů typu, které jsou nadtypy Řetězec.

Zástupný parametrizovaný typ není typ v běžném smyslu (odlišný od neparametrizované třídy/rozhraní nebo surového typu).

Typy parametrizované zástupnými znaky lze použít pro psaní (jako neparametrizované třídy a rozhraní):

  • jako argument a návratové typy metod
  • jako typ pole nebo lokální referenční proměnné
  • jako typ komponenty argumentu typu poleas jiných parametrizovaných typů
  • jako cílový typ v obsazení

Nejen typy mohuen být oční ale i metody mohún být oční. Statické a nestatické metody a také konstruktori mohu mít parametry typu. Syntaxe pro deklarace parametrů formálního typu je podobná syntaxi pro generické typy. Část parametru type je ohraničena složenými závorkami a je zobrazena před metodou návratového typu. Jeho syntaxe a vyštné je shhodní se seznamem parametrů typu generického typu.

Zde je příklad generika max metoda, která počítá největší hodnotu v kolekci prvků neznámého typu A .

Příklad (běžné metody):

class Collections {
  veřejná statika <A rozšiřuje Comparable<A>> A max (Kolekce< A > xs) {
    Iterátor< A > xi = xs.iterator();
    A w = xi.další();
    while (xi.hasNext()) {
      A x = xi.další();
      if (w.compareTo(x) < 0) w = x;
    }
    návrat w;
  }
} 

The max metoda má jeden parametr typu s názvem A .  Je to zástupný symbol pro typ prvku kolekce, na kterém metoda funguje. Parametr type má vazbu; musí to být typ, který je podtypem Srovnatelné<A>

Příklad (tentokrát stejného obecného typu s meze):

veřejné rozhraní Porovnatelné<T> {
  public int CompareTo(T arg);
}
veřejná třída TreeMap<Key rozšiřuje Comparable<Key> ,Data>{
  soukromá statická třída Entry<K,V> {
     K klíč;
     V hodnota;
     Vstup<K,V> vlevo = null;
     Vstup<K,V> vpravo = null;
     Vstup<K,V> rodič;
  }
  soukromý přechodný Entry<Key,Data> root = null;
  ...
  private Entry<Key,Data> getEntry(klíč klíče) {
     Entry<Key,Data> p = kořen;
     Klíč k = klíč;
     while (p != null) {
       int cmp = k. porovnatTo (p.key) ; 
       if (cmp == 0)
         vrátit p;
       jinak if (cmp < 0)
         p = p.vlevo;
       jiný 
         p = p.vpravo; 
     }
     return null;
  }
  public boolean obsahujeKey(klíč klíče) {
     return getEntry(klíč) != null;
  }
  ...
}

Ve výše uvedeném příkladu parametr type Klíč má vázáno Srovnatelné<Key> .  Specifikace vazby má dva účinky:

  • Umožňuje přístup k metodám, které vazba specifikuje .  V příkladu vázaný Srovnatelné<Key> umožňuje přístup k srovnáníTo metoda, kterou chceme použít při implementaci našeho Stromová mapa třída.
  • Pro konkretizaci obecného typu lze použít pouze typy „v rámci mezí“.   V příkladu je parametrizovaný typ jako např Stromová mapa<Číslo,String> by byl zamítnut, protože typ Číslo není podtypem Srovnatelné<Číslo> .  Parametrizovaný typ jako Stromová mapa<String,String> by bylo přijato, protože typ String je v mezích, tj. je podtypem Srovnatelné<String> .

Jako vázané parametry typu lze použít všechny třídy, rozhraní a typy výstupů, včetně externích a interních typů.  Ani primitivní typy, ani typy polí nelze použít jako spojení s parametrem typu.

Příklady (typ parametrů ohraničení):

třída X0 <T prodlužuje int > { ... }      // chyba
třída X1 <T prodlužuje Objekt[] > { ... } // chyba
třída X2 <T prodlužuje Číslo > { ... }
třída X3 <T prodlužuje Řetězec > { ... }
třída X4 <T prodlužuje Spustitelný > { ... }
třída X5 <T prodlužuje Závit.Stav > { ... }
třída X6 <T prodlužuje Seznam > { ... }
třída X7 <T prodlužuje Seznam<String> > { ... }
třída X8 <T prodlužuje List<? rozšiřuje Číslo> > { ... }
třída X9 <T prodlužuje Srovnatelné<? super číslo> > { ... }
třída X10<T prodlužuje Mapa.Vstup<?,?> > { ... }

Ukázka kódu ukazuje, že primitivní typy jako např int a typy polí jako např Objekt[] nejsou povoleny, protože jsou vázány na parametr typu.

Typy tříd, jako např Číslo nebo Řetězec a typy rozhraní, jako např Spustitelný , jsou povoleny jako vázané na parametr typu.

Výčtové typy, jako např Závit.Stav jsou také povoleny jako vázané na parametr typu. Závit.Stav je příkladem vnořeného typu použitého jako vázaný parametr typu.  Jsou povolené a nestatické vnitřní typy.

Nezpracované typy jsou povoleny, protože jsou svázány s parametrem typu; Seznam Jsem příkladem.

Parametrizované typy jsou povoleny jako vázané na parametris typu, včetně konkrétních parametrizovaných typů, jako jsou např Seznam<String> , ohraničené zástupné parametrizované typy jako např List<? rozšiřuje Číslo> a Srovnatelné<? super Long> , a neomezené zástupné parametrizované typy, jako je Mapa.Vstup<?,?> .  Vazba, což je typ parametrizovaný zástupnými znaky, umožňuje jako typ argumentu všechny typy, které patří do rodiny typů, které zástupný znak označuje.  Vazba parametrizovaného typu se vysutnými ženami poskytuje pouze omezený přístup k polím a metodám; omezení závisí na typu reprezentativní postavy.

Příklad (k dispozici pro parametrizovaný typ jako vázaného na parametr typu):

třída X< T rozšiřuje List<? rozšiřuje Číslo> > {
  public void someMethod(T t) {
    t.add(new Long(0L));    // chyba
    Číslo n = t.remove(0);
  }
}
třída Test {
  public static void main(String[] args) {
     X<ArrayList< Dlouho >> x1 = new X<ArrayList<Long>>(); 
     X<ArrayList< Řetězec >> x2 = nové X<ArrayList<String>>(); // chyba
  }
}

Referenční proměnné typu T (parametr typu) se zachází jako s referenčními proměnnými typu zástupného znaku (vazba parametru typu).  V našem příkladu to má za následek, že kompilátor odmítne vyvolání metod, které přebírají argument typu „neznámý“, který zastupuje parametr type, jako např. Seznam.přidat , protože vazba je parametrizovaný typ zapútným znakem s horní hránikí.
Zároveň vázaný List<? rozšiřuje Číslo> určuje typy, které lze použít jako argumenty typu. Kompilátor přijímá všechny argumenty typu, které patří do rodiny typů List<? rozšiřuje Číslo> , tedy všechny podtypy Seznam s argumentem typu, který je podtypem Číslo .

Parametr typu lze použít jako odkaz na jiný parametr typu.

Příklad (typ parametru použitý jako typ parametru připojení):

třída Triple <T> {
  soukromý T fst, snd, trd;
  veřejné < U prodlužuje T , PROTI prodlužuje T , W prodlužuje T > Triple(U arg1, V arg2, W arg3) {
    fst = arg1;
    snd = arg2;
    trd = arg3;
  }
}

V tomto příkladu parametr type T parametrizované třídy se používá jako vazba parametrů typu U ,  PROTI a W parametrisovane metody instance teto třídy.

Mezi další možnosti použití parametrů typu jako hranic pro jiné parametry typu patří situace, kdy je interní typ definován v rámci generického typu nebo je definována místní třída v rámci generické metody.  Je dokonce povoleno použít parametr typu jako odkaz na jiný parametr typu ve stejné sekci parametrů typu.

Vazba, která je třídou, poskytuje přístup všem svým veřejným členům, tedy veřejným polím, metodám a vnořeným typům. Nejsou zpřístupněny pouze konstruktori, protože neexistuje žádná záruka, ze podtřida vázaných má esteske konstruktori jako vázaná.

Příklad (třídy použit jako parametr vazby typu):

veřejná třída Supertřída {     // statické členy
    veřejný výčet EnumType {THIS, THAT}
    public static Object staticField;
    public static void staticMethod() { ... }

    // nestatické členy
    public class InnerClass { ... }
    public Object nonStaticField;
    public void nonStaticMethod() { ... }

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

    // soukromí členové
    private Object privateField; 

    ...
}

veřejná finálová třída SomeClass<T prodlužuje Supertřída > {
    soukromý T objekt;
    public SomeClass(T t) { object = t; } 

    public String toString() {
        návrat
         "static vnořený typ    : "+T.EnumType.class+"\n" 
        +"statické pole          : "+T.staticField+"\n"
        +"statická metoda         : "+T.staticMethod()+"\n"
        +"nestatický vnořený typ: "+T.InnerClass.class+"\n"
        +"nestatické pole      : "+object.nonStaticField+"\n"
        +"nestatická metoda     : "+object.nonStaticMethod()+"\n"
        +"constructor           : "+(nové T())+"\n"                    // chyba
        +"soukromý člen        : "+object.privateField+"\n"           // chyba 
        ;
    }
}

Vázaný Supertřída poskytuje přístup ke svým vnořeným typům, statickým polím a metodám a nestatickým polím a metodám.  Pouze konstruktor není přístupný.  Je to proto, že konstruktory se nedědí. Každá podtřída definuje své vlastní konstruktory a nemusí podporovat konstruktory své nadtřídy.  Proto neexistuje žádná záruka, že podtřída Supertřída bude mít stejný konstruktor jako jeho nadtřída.

Kontext, ve krom Enum<E rozšiřuje Enum<E>> “ se objeví deklarace Enum třída v balíčku java.lang :

veřejná abstraktní třída Enum<E rozšiřuje Enum<E>> {
  ...
}

Typ Enum je společná základní třída všech typů výčtu.  V Javě je typ výčtu jako např Barva je přeložen do třídy Barva která se rozšiřuje Enum<Color> . Účel nadtřídy Enum je przewiat funccije jsuo commene pro alle typy výčtů.

Zde je náčrt tříd Enum :

veřejná abstraktní třída Enum< E rozšiřuje Enum<E>> implementuje Comparable< E >, serializovatelný {
  soukromý konečný Název řetězce;
  public final String name() { ... }   private final int ordinal;
  public final int ordinal() { ... }

  protected Enum(název řetězce, int pořadové číslo) { ... }

  public String           toString() { ... }
  public final boolean equals(Object other) { ... }
  public final int hashCode() { ... }
  protected final Object clone() vyvolá CloneNotSupportedException { ... }
  public final int CompareTo( E o) { ... }

  veřejné finále Class< E > getDeclaringClass() { ... }
  public static <T rozšiřuje Enum<T>> T valueOf(Class<T> enumType, String name) { ... }
}

Překvapivá nemovitost ve výkazu “ Enum<E rozšiřuje Enum<E>> “ je skutečnost, že nově definovaná třída Enum a jeho nově definovaný parametr typu E se objeví v mez parametru stejného typu.  Znamená to, že Enum typ musí být vytvořen pro jeden z jeho podtypů.  Abyste pochopili, proč to dává smysl, zvažte, že každý typ výčtu je přeložen do podtypu Enum .

Zde je vykonstruovaný typ výčtu Barva :

enum Barva {ČERVENÁ, MODRÁ, ZELENÁ}

Kompilátor jej přeloží do následující třídy:

veřejná závěrečná třída Barva rozšiřuje Enum<Color> {
  public static final Color[] values() { return (Color[])$VALUES.clone(); }
  public static Hodnota barvyOf(název řetězce) { ... }   private Color(String s, int i) { super(s, i); }

  veřejná statická finální Barva ČERVENÁ;
  veřejná statická finální Barva MODRÁ;
  veřejná statická finální Barva ZELENÁ;

  soukromé statické konečné Barva $VALUES[];

  statické {
    ČERVENÁ = nová barva("ČERVENÁ", 0);
    MODRÁ = new Color("BLUE", 1);
    ZELENÁ = nová barva("ZELENÁ", 2);
    $VALUES = (nová barva[] { ČERVENÁ, MODRÁ, ZELENÁ });
  }
}

Dědičnost má za následek, že Barva typ zdědí všechny metody implementované v Enum<Color> .  Mezi nimi je srovnáníTo metoda.  The Barva. srovnáníTo metoda by pravděpodobně měla trvat a Barva jako argument.  Aby se to stalo tř Enum je generický a Enum.compareTo metoda trvá Enum parametr typu ‘s E jako argument.  V důsledku toho zadejte Barva odvozené z Enum<Color> zdědí a srovnáníTo metoda, která vyžaduje a Barva jak a argumentovat, přesně jak má.
Покуть розебереме продажа “ Enum<E rozšiřuje Enum<E>> “ můžeme vidět, že tento vzor má několik aspektů.

Za prvé, skutečnost, že parametr vázaný na typ je samotný typ: “ Enum <E se prodlužuje Enum <E>> Zajišťuje, že pouze podtypy typu Enum jsou povoleny jako argumenty typu. (Teoreticky napište Enum mohla být vytvořena sama o sobě, jako v Enum<Enum> , ale rozhodně to není zamýšleno a je těžké si představit situaci, která by byla takto konkrétně užitečná.)

Za druhé je tu skutečnost, že typ vázaný na parametr je typ parametrizovaný Enum <E> , který používá parametr type E jako argument typu vazby. Tato deklarace zajišťuje, že vztah dědičnosti mezi podtypem a konkretizací Enum je ve formě X rozšiřuje Enum<X> “. Subtyp jako “ X rozšiřuje Enum<Y> ” nelze deklarovat kvůli argumentu typu Y nebude v mezích; pouze podtypy Enum<X> jsou v mezích

Za třetí je pravda, že Enum je na prvním místě generický.  Znamená to, že některé z metod tř Enum vzít argument nebo vrátit hodnotu neznámého typu (nebo jinak záviset na neznámém typu). Jak již víme, tento neznámý typ bude později podtypem X z Enum<X> .  Tedy v parametrizovaném typu Enum<X> , tyto metody zahrnují podtyp X , a jsou zděděny do podtypu X .  The srovnáníTo metoda je exemplarem takke metody; je zděděna z nadtřídy do káké podtřídy a v káké kádí má podpis specifický pro podtřídu.

Abych to shrnul, prohlášení “ Enum<E rozšiřuje Enum<E>> “ lze dešifrovat jako: Enum je generický typ, který lze konkretizovat pouze pro jeho podtypy, a tyto podtypy zdědí některé užitečné metody, z nichž některé přebírají argumenty specifické pro podtyp (nebo jinak závisí na podtypu).

Dolní mez Typ Parametry tříd

Parametry typu mohou mít několik mezí, jako např třída Box<T rozšiřuje Číslo> {...} . Ale parametr typu nemůže mít žádnou spodní hranici, to znamená konstrukt jako např třída Box<T velký Číslo> {...} není povoleno  Proč ne?  Odpověď zní: je to k ničemu, protože by se tím nic nekoupilo, kdyby to bylo povoleno.  Podívejme se, proč jsou parametry typu dolní meze tříd matucí, žebu prozkoumáme co signítre horní mez parametrio typu.

Horní mez parametry typu má tři efekty:

    1. Omezená instance. Horní hranice omezuje sadu typů, které lze použít pro konkretizaci generického typu.  Pokud prohlásíme a třída Box<T rozšiřuje Číslo> {...} pak by kompilátor zajistil, že pouze podtypy Číslo lze použít jako argument typu.  To znamená, a Box<Číslo> nebo a Box<Long> je povoleno, ale a Box<OObject> nebo Box<String> by bylo odmítnuto

Příklad (omezené konkretizace kvůli horní hranici parametru typu):
třída Box<T rozšiřuje Číslo> { 
   soukromá hodnota T; 
   public Box(T t) { hodnota = t; } 
   ...
}  třída Test { 
   public static void main(String[] args) { 
       Box<Long> boxOfLong = nový Box<Long>(0L);   // dobře
       Box<String> boxOfString = new Box<String>(""); // chyba: Řetězec není v mezích
   }
}

  1. Přístup k nestatickým členům. Horní hranice umožňuje přístup ke všem veřejným nestatickým metodám a polím horní hranice.  Při realizaci našeho třída Box<T rozšiřuje Číslo> {...} můžeme vyvolat všechny veřejné nestatické metody definované ve třídě Číslo , jako např intValue() například.  Bez horní hranice by kompilátor jakékoli takové vyvolání odmítl. Příklad (přístupu k nestatickým členům kvůli horní hranici parametru typu):

třída Box<T rozšiřuje Číslo> { 
   soukromá hodnota T; 
   public Box(T t) { hodnota = t; } 
   public int increment() { return value.intValue()+1; } // <= by bez vazby na číslo byla chyba
   ...
} 

    1. Typ Erasure. Horní mez vlevo se používá pro vymazání typu a nahrazuje parametr typu v bajtovém kódu.  V našem třída Box<T rozšiřuje Číslo> {...} všechny výskyty T bude nahrazena horní hranicí Číslo .  Například pokud třída Krabice má soukromé pole typu T a způsob neplatná sada (obsah T) pro nastavení tohoto soukromého pole by pole bylo typu Číslo po vymazání typu a metoda by byla převedena na metodu void set (číslo obsahu) .

Příklad (při použití typu – použijte horní okraj v parametru typu před typ mazání):
třídy Box< T rozšiřuje číslo > { 
   soukromé T hodnota; 
   veřejná schránka ( T t) { hodnota = t; } 
   ...
} 

      Příklad (při použití typu – použijte horní okraj v parametru typu

po

      typ mazání):

 

třída Box { 
   soukromé Číslo hodnota; 
   veřejná schránka ( Číslo t) { hodnota = t; } 
   ...
}

    Kromě toho se horní mez nejvíce vlevo objeví na dalších místech, jako jsou automaticky vložené odlitky a metody mostu.

Pokud by byly povoleny dolní meze pro parametry typu, jaké vedlejší účinky by měly nebo měly mít? Pokud konstrukce jako např třída Box<T velký Číslo> {...} byly povoleny, co by to znamenalo?  Co by znamenaly 3 vedlejší účinky hranice parametru horního typu – omezená konkretizace, přístup k nestatickému členu, vymazání typu – pro dolní hranici?

Omezené instance. Kompilátor by mohl omezit sadu typů, které lze použít pro konkretizaci obecného typu s parametrem typu s dolní mezí.  Kompilátor může například povolit vytváření instancí, jako je např Box<Číslo> a Box<OObject> od a Box<T velký Číslo> a odmítnout instance jako např Box<Long> nebo Box<Short> .  To by byl účinek v souladu s omezujícím vedlejším účinkem popsaným pro horní hranice parametrů.

Přístup k nestatickým členům. Nižší mez parametru typu nedává přístup k žádným konkrétním metodám kromě těch, které jsou zděděny ze třídy Objekt . V příkladu Box<T velký Číslo> supertypy Číslo nemají nic společného, ​​kromě toho, že se jedná o referenční typy, a tedy jejich podtypy Objekt .  Kompilátor nemůže předpokládat, že pole typu T je typu Číslo nebo jeho podtyp.  Místo toho pole typu T může být jakéhokoli supertypu Číslo , jako např Serializovatelné nebo Objekt .  Vyvolání metody jako je např intValue() již není typově bezpečný a kompilátor by jej musel odmítnout. V důsledku toho by nižší mez parametru typu neposkytla přístup k nestatickým členům nad rámec těch, které jsou definovány ve třídě Objekt a má tedy stejný účinek jako „bez vazby“.

Typ Erasure .  Podle této logické linie nemá smysl nahrazovat výskyty parametru type jeho dolní hranicí zcela vlevo.  Deklarování metody jako konstruktoru Krabice( T t) jako konstruktér Krabice( Číslo t) vzhledem k tomu nedává smysl T je nahrazen nadtypem Číslo .  An Objekt může být správně předán konstruktoru v instanciaci Box<OObject> a konstruktér by to odmítl.  To by bylo smrtelně špatně.   Vymazání typu by tedy nahradilo všechny výskyty proměnné typu T podle typu Objekt .  Opět platí, že spodní mez by měl stejný efekt jako „bez meze“.

Chcete svetsut, co by to nadlo, kbyby oba nijjem _a_ byly povoleny horní hranice?   Osobně na to nechci ani myslet a radje bych to zařadil pod “nezvládnutélné”, pokud dovolíte.

Sečteno a podtrženo: vše, co " velký „Vázaný by tě koupil je omezení, které platí pouze pro supertypy Číslo lze použít jako argumenty typu.  A i to je často nepochopeno.  NEZNAMENALO by to třída Box<T super číslo> {...} obsahuje pouze instance supertypů Číslo .  Přesně naopak – jak ukazuje příklad níže.

Příklad (při použití typu – použijte horní okraj v parametru typu před typ mazání):

třídy Box< T super číslo > {
   soukromé T hodnota;
   veřejná schránka ( T t) { hodnota = t; }
   ...
}

Příklad (při použití typu – použijte horní okraj v parametru typu po typ mazání):

třída Box {
   soukromé Objekt hodnota;
   veřejná schránka ( Objekt t) { hodnota = t; }
   ...
}

A třída Box<T velký Číslo> {...} by se přeložilo podle typu mazání na a Krabice obsahující an Objekt pole a jeho konstruktor by byl přeložen do Box (Objekt t) . To se zásadně liší od a třída Box<T rozšiřuje Číslo> {...} , což by bylo přeloženo do a Krabice obsahující a Číslo pole a jeho konstruktor by byl přeložen do Box (číslo t) . V důsledku toho a Box<Číslo> vytvořené z a třída Box<T rozšiřuje Číslo> {...} by se lišil od a Box<Číslo> instance z a třída Box<T super číslo> {...} , což pravděpodobně způsobilo zmatek.  Z tohoto důvodu nemají nižší meze a typových parametrů tříd smysl.

 


 

Parametry metod typu s dolní hranicí

Spojení mezi metodami a jejich typem argumentů může být příležitostně užitečné pro typ parametru s nižším limitem.

Příklad (metody, které využívají typ parametru se spodním limitem):

třída Pair<X,Y> {
   soukromé X první;
   soukromá Y sekunda;
   ...
   veřejné < Super X , B super Y > B addToMap(Map<A,B> mapa) { // chyba: parametr typu nemůže mít spodní hranici
      return map.put(první, druhý);
   }
}
třída Test { 
   public static void main(String[] args) { 
     Pair<String,Long> pair = new Pair<>("ABC",42L);
     Map<CharSequence, Number> mapa = HashMap<CharSequence, Number>();
     Číslo číslo = pair.addToMap(map);
   }
}

The addToMap() metoda přidá obsah dvojice do mapy.  Jakákoli mapa, která může obsahovat supertypy X a Y by udělal.  Mapa je dát() metoda vrací hodnotu nalezenou v mapě pro daný klíč, pokud již pro klíč v mapě existuje položka páru klíč–hodnota.  Návratová hodnota mapy dát() metoda se vrátí z addToMap() metoda.  Za těchto okolností bychom chtěli deklarovat metodu, jak je ukázáno výše: Mapa je parametrizována pomocí supertypů parametrů typu dvojice a addToMap() várátový typ metody je typ valority mapy.

Protože kompilátor neumožňuje dolní meze parametrů typu, musíme jej obejít.

Jedním z řešení, které mě napadá, je použití zástupného znaku, protože zástupné znaky mohou mít nižší meze.  Zde je řešení pomocí zástupného symbolu.

Příklad (vynechání předchozího příkladu pomocí náhradních znaků):

třída Pair<X,Y> {
   soukromé X první;
   soukromá Y sekunda;
   ...
   veřejnost Objekt addToMap(Map< ? Super X , ? super Y mapa >) { 
      return map.put(první, druhý);
   }
}
třída Test { 
   public static void main(String[] args) { 
     Pair<String,Long> pair = new Pair<>("ABC",42L);
     Map<CharSequence, Number> mapa = HashMap<CharSequence, Number>();
     Číslo číslo = (Číslo) pair.addToMap(mapa);
   }
}

Funguje to, až na to, že neexistuje způsob, jak deklarovat návratový typ jako požadovaný.  Byl by to supertyp Y koření kompilátor zachytí z typu mapy, ale jeztá zaká záché syntaxe pro jeho spékificaci.  Nesmíme deklarovat vátravovový typ a “ ? super Y “ protože ” ? super Y ” je reprezentativní znak, nikoli typ, ale není povolen jako návratový typ. Nemáme na výběr a musíme toho využít Objekt místo toho jako návratový typ naší metody.  Tento poněkud nespecifický návratový typ zase nutí volající addToMap() metodou přetypování návratové hodnoty dolů z Objekt na jeho skutečný typ.  Není to přesně to, co jsem měl na mysli.

Dalším řešením je použití statických metod.  Zde je statické řešení namísto nestatické metody.

Příklad (vynechání předchozího příkladu pomocí statické metody):

třída Pair<X,Y> {
   soukromé X první;
   soukromá Y sekunda;
   ...
   veřejnost statický < A , B ,X rozšiřuje A ,Y rozšiřuje B > B addToMap(Pair<X,Y> pair, Map< A , B mapa >) {
      return map.put(pár.první,pár.druhý);
   }
}
třída Test { 
   public static void main(String[] args) { 
     Pair<String,Long> pair = new Pair<>("ABC",42L);
     Map<CharSequence, Number> mapa = HashMap<CharSequence, Number>();
     Číslo číslo = Pár .addToMap( pár ,mapa);
   }
}

Obecný addToMap() metoda má čtyři parametry typu: dva zástupné symboly X a Y pro typ dvojice a dva zástupné symboly A a B pro typ mapy. A a B jsou supertypy X a Y , protože X a Y   jsou prohlášeny s A a B jako jejich horní hranice. (Všimněte si, že parametry typu obecné metody X a Y nemají s tím nic společného Pár třídy X a Y parametry.  Jména X a Y jsou znovu otaku pro generickou metudu, aby byly szőtő rozpoznatelné jako parametry typu páru. Pomocí čtyř typových parametrů můžeme deklarovat přesný návratový typ podle potřeby: je to stejný typ jako hodnotový typ mapy.

Příklad (neoprávněného kontextu použití parametru typu ve statickém genericé classy):

třída SomeClass <T> {
  // statický inicializátor, statické pole, statická metoda
  statický {
    Některé třídy< T Test > = novinka SomeClass< T >(); // chyba
  }
  soukromé statický T globalInfo;          // chyba
  veřejnost  statický T getGlobalInfo() {        // chyba
    vrátit globalInfo;
  }
  // nestatický inicializátor, nestatické pole, nestatická metoda
  { 
    Některé třídy< T Test > = novinka SomeClass< T >();
  }
  soukromé        T localInfo;
  veřejnost         T getLocalInfo() { 
    vrátit localInfo;
  }
  // statické vnořené typy
  veřejnost statický třída Selhání prodlužuje výjimku {
    soukromé finále T info;           // chyba
    veřejné selhání ( T t) { info = t; }      // chyba
    veřejnost T getInfo() { return info; }    // chyba
   }
  soukromé rozhraní Kopírovatelné {
    T kopie();                       // chyba
  }
  soukromé enum stát {
    PLATNÝ, NEPLATNÝ;
    soukromé T info; // chyba
    public void setInfo( T t) { info = t; } // chyba
    veřejnost T getInfo() { return info; }    // chyba
  }
  // nestatické vnořené typy
  veřejnost třída Accessor {
    veřejnost T getInfo() { return localInfo; }
  }
}

Příklad ukazuje, že parametr typu nelze použít ve statickém kontextu generických tříd.  Také ukazuje, že vnitřní rozhraní a typy výstupu jsou považovány za statické členské třídy.  Pouze interní třídy, tedy statické vnořené třídy, mohou používat parametr typu obklopující generické klady.

Rozsah rozhraní typu je celé definiční rozhraní s výjimkou typů poly nebo vnořených.  Je to proto, že pole a vnořené typy definitivní v prádni jsou implicitně statické.

Příklad (neoprávněného použití typu parametru v generickém rozhraní):

rozhraní SomeInterface <T> {
  // pole
  Některé třídy< T Hodnota > = nová SomeClass< T >();  // chyba
  // vnořený typ
  třída Accessor {
    veřejnost T getInfo() {            // chyba
      return value.getGlobalInfo();
    }
  }
  // metody
  T getValue();
}

Příklad ukazuje, že pole rozhraní jsou implicitně statická, takže parametr typu nelze použít nikde v deklaraci pole obecného rozhraní.  Podobně je vnořená třída považována za statickou vnořenou třídu, nikoli za vnitřní třídu, a z tohoto důvodu je použití parametru type kdekoli ve vnořené třídě nezákonné.

Řešení pro vnořené statické třídy a rozhraní:

V případě statických vnořených tříd a právní to něi velká pohroma.  Jako řešení můžeme vygenerovat jednu statickou ulici nebo rozhraní.

Příklad (rešení – vygenerujte vnořený statický typ):

třída Wrapper <T> {
  soukromé finále T theObject;

  veřejný obal ( T t) { theObject = t; }
  veřejnost T getWrapper() { return theObject; }   veřejný Neměnný <T> makeImmutable() {
        vrátit nový Immutable <T> (Objekt);
  }
  veřejné proměnlivé <T> makeMutable() {
        vrátit nový Mutable <T> (Objekt);
  }
  private static <A> A makeClone(A theObject) { ... }

  public static final class Immutable <A> { // je nyní generická třída
        soukromé finále A theObject;

        veřejný neměnný( A arg) {
            theObject = makeClone(arg);
        }
        veřejnost A getWrappedItem() {
            return makeClone(theObject);
        }
  }
  veřejná statická třída Mutable <A> {
        ... podobné ...
  }
}

Pro vnořené typy výčtu neexistuje žádné takové řešení, protože nemohou být obecné.

Řešení pro vnořené statické třídy:

Pokud existuje třída vnořeným statickým typem, alternativním řešením by bylo převédení statické třídy na nestatickou vůrní třidu.

Příklad (řešení – použijte vnitřní třídu):

třída Wrapper <T> {
  soukromé finále T theObject;

  veřejný obal ( T t) { theObject = t; }
  veřejnost T getWrapper() { return theObject; }   public Proměnlivé makeMutable() {
      návrat tento. new Mutable(theObject);
  }
  public Immutable makeImmutable() {
      návrat tento. new Immutable(theObject);
  }
  private static <A> A makeClone(A theObject) { ... }

  public final class Immutable {  // již není statická třída
      soukromé finále T theObject;

      veřejný neměnný( T arg) {
          theObject = makeClone(arg);
      }
      veřejnost T getWrappedItem() {
          return makeClone(theObject);
      }
  }
  veřejná třída Proměnlivý 
        ... podobné ...
  }
}

Toto zástupné řešení je spojeno s určitou režií, protože všechny vnitřní třídy mají skrytý odkaz na instance vnějšího typu, které v tomto příkladu nejsou potřeba ani použity; skrytý odkaz je jen zavazadlo.  Interní třídy jsou často kombinovány s rozhraními, takže interní třída zůstává soukromým detailem implementace okolní třídy.  Totéž můžeme udělat zde.

Příklad (upřesněno předchozí řešení):

třída Wrapper <T> {
  soukromé finále T theObject;

  veřejný obal ( T t) { theObject = t; }
  veřejnost T getWrapper() { return theObject; }   veřejné proměnlivé <T> makeMutable() {
      return this.new Mutable(theObject);
  }
  veřejný Neměnný <T> makeImmutable() {
      return this.new Immutable(theObject);
  }
  private static <A> A makeClone(A theObject) { ... }

  veřejné rozhraní Immutable<S> {
      S getWrappedItem();
  }
  veřejné rozhraní Mutable<S> {
      S getWrappedItem();
      void setWrappedItem(S arg);
  }
  soukromé závěrečná třída ImmutableImplementation implementuje Immutable<T> { 

      soukromé finále T theObject;

      public ImmutableImplementation(T arg) {
          theObject = makeClone(arg);
      }
      public T getWrappedItem() {
          return makeClone(theObject);
      }
  }
  soukromé třída MutableImplementation implementuje Mutable<T> { 
        ... podobné ...
  }
}

Jak vidíte, interní veřejná rozhraní musí být generická, zatímco interní soukromé třídy mohou používat uzavírací parametry třídy.

 

 

 

 

 

Zanechat odpověď