The Java Generics programovanie je zavedené v J2SE 5 na prácu s typovo bezpečnými objektmi. Vďaka tomu je kód stabilný detekciou chýb v čase kompilácie.

anakonda vs pytónový had

Pred generikami môžeme do zbierky uložiť akýkoľvek typ objektov, teda negenerické. Teraz generiká nútia programátora Java ukladať konkrétny typ objektov.

Výhoda Java Generics

Generiká majú hlavne 3 výhody. Sú nasledovné:

1) Typová bezpečnosť: V generikách môžeme držať iba jeden typ objektov. Nedovoľuje ukladať iné predmety.

Bez Generics môžeme ukladať akýkoľvek typ objektov.

 List list = new ArrayList(); list.add(10); list.add('10'); With Generics, it is required to specify the type of object we need to store. List list = new ArrayList(); list.add(10); list.add('10');// compile-time error 

2) Typové odlievanie sa nevyžaduje: Nie je potrebné pretypovať objekt.

Pred Generics musíme zadať cast.

 List list = new ArrayList(); list.add('hello'); String s = (String) list.get(0);//typecasting After Generics, we don't need to typecast the object. List list = new ArrayList(); list.add('hello'); String s = list.get(0); 

3) Kontrola času kompilácie: Kontroluje sa v čase kompilácie, takže problém nenastane počas behu. Dobrá programovacia stratégia hovorí, že je oveľa lepšie riešiť problém v čase kompilácie ako v čase behu.

 List list = new ArrayList(); list.add('hello'); list.add(32);//Compile Time Error 

Syntax použiť generickú kolekciu

 ClassOrInterface 

Príklad používať Generics v jazyku Java

 ArrayList 

Úplný príklad generík v Jave

Tu používame triedu ArrayList, ale môžete použiť akúkoľvek triedu kolekcie, ako napríklad ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator atď.

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Výkon:

 element is: jai rahul jai 

Príklad Java Generics pomocou mapy

Teraz budeme používať prvky mapy pomocou generík. Tu musíme odovzdať kľúč a hodnotu. Poďme to pochopiť na jednoduchom príklade:

 import java.util.*; class TestGenerics2{ public static void main(String args[]){ Map map=new HashMap(); map.put(1,&apos;vijay&apos;); map.put(4,&apos;umesh&apos;); map.put(2,&apos;ankit&apos;); //Now use Map.Entry for Set and Iterator Set<map.entry> set=map.entrySet(); Iterator<map.entry> itr=set.iterator(); while(itr.hasNext()){ Map.Entry e=itr.next();//no need to typecast System.out.println(e.getKey()+&apos; &apos;+e.getValue()); } }} </map.entry></map.entry>

Výkon

 1 vijay 2 ankit 4 umesh 

Generická trieda

Trieda, ktorá môže odkazovať na akýkoľvek typ, je známa ako generická trieda. Tu používame parameter typu T na vytvorenie generickej triedy konkrétneho typu.

Pozrime sa na jednoduchý príklad vytvorenia a použitia generickej triedy.

Vytvorenie všeobecnej triedy:

 class MyGen{ T obj; void add(T obj){this.obj=obj;} T get(){return obj;} } 

Typ T znamená, že môže odkazovať na akýkoľvek typ (napríklad reťazec, celé číslo a zamestnanec). Typ, ktorý zadáte pre triedu, sa použije na uloženie a načítanie údajov.

linux premenovať adresár

Použitie všeobecnej triedy:

Pozrime sa na kód na použitie generickej triedy.

 class TestGenerics3{ public static void main(String args[]){ MyGen m=new MyGen(); m.add(2); //m.add('vivek');//Compile time error System.out.println(m.get()); }} 

Výkon

 2 

Typ Parametre

Konvencie pomenovania parametrov typu sú dôležité na dôkladné naučenie sa generík. Bežné parametre typu sú nasledovné:

výlet ale

1. T - Typ
2. E - Element
3. K - kľúč
4. N - Číslo
5. V - Hodnota

Všeobecná metóda

Podobne ako generická trieda môžeme vytvoriť generickú metódu, ktorá môže akceptovať akýkoľvek typ argumentov. Tu je rozsah argumentov obmedzený na metódu, kde je deklarovaný. Umožňuje statické aj nestatické metódy.

Pozrime sa na jednoduchý príklad generickej metódy java na tlač prvkov poľa. Používame tu A na označenie prvku.

 public class TestGenerics4{ public static void printArray(E[] elements) { for ( E element : elements){ System.out.println(element ); } System.out.println(); } public static void main( String args[] ) { Integer[] intArray = { 10, 20, 30, 40, 50 }; Character[] charArray = { 'J', 'A', 'V', 'A', 'T','P','O','I','N','T' }; System.out.println( 'Printing Integer Array' ); printArray( intArray ); System.out.println( 'Printing Character Array' ); printArray( charArray ); } } 

Výkon

 Printing Integer Array 10 20 30 40 50 Printing Character Array J A V A T P O I N T 

Zástupný znak v Java Generics

? symbol (otáznik) predstavuje prvok zástupného znaku. To znamená akýkoľvek typ. Ak píšeme , znamená to akúkoľvek podradenú triedu čísla, napr. Integer, Float a double. Teraz môžeme zavolať metódu triedy Number prostredníctvom akéhokoľvek objektu triedy potomka.

Zástupný znak môžeme použiť ako a typ parametra, pole, návratový typ alebo lokálna premenná. Nie je však povolené používať zástupný znak ako argument typu pre vyvolanie generickej metódy, vytvorenie inštancie generickej triedy alebo nadtyp .

Pochopme to na príklade uvedenom nižšie:

 import java.util.*; abstract class Shape{ abstract void draw(); } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle');} } class GenericTest{ //creating a method that accepts only child class of Shape public static void drawShapes(List lists){ for(Shape s:lists){ s.draw();//calling method of Shape class by child class instance } } public static void main(String args[]){ List list1=new ArrayList(); list1.add(new Rectangle()); List list2=new ArrayList(); list2.add(new Circle()); list2.add(new Circle()); drawShapes(list1); drawShapes(list2); }} 

Výkon

 drawing rectangle drawing circle drawing circle 

Horné ohraničené zástupné znaky

Účelom zástupných znakov s hornou hranicou je znížiť obmedzenia premennej. Obmedzuje neznámy typ na špecifický typ alebo podtyp tohto typu. Používa sa deklarovaním zástupného znaku ('?'), za ktorým nasleduje kľúčové slovo extends (v prípade triedy) alebo implementuje (v prípade rozhrania), za ktorým nasleduje jeho horná hranica.

Syntax

 List 

Tu,

? je zástupný znak.

predlžuje , je kľúčové slovo.

číslo , je trieda prítomná v balíku java.lang

Predpokladajme, že chceme napísať metódu pre zoznam Number a jeho podtypy (ako Integer, Double). Použitím Zoznam je vhodný pre zoznam typu Number alebo niektorú z jeho podtried, zatiaľ čo Zoznam funguje len so zoznamom typu Číslo. takže, Zoznam je menej obmedzujúce ako Zoznam .

Príklad zástupného znaku hornej hranice

V tomto príklade používame zástupné znaky hornej hranice na napísanie metódy pre zoznam a zoznam.

java nahradiť všetok reťazec

 import java.util.ArrayList; public class UpperBoundWildcard { private static Double add(ArrayList num) { double sum=0.0; for(Number n:num) { sum = sum+n.doubleValue(); } return sum; } public static void main(String[] args) { ArrayList l1=new ArrayList(); l1.add(10); l1.add(20); System.out.println('displaying the sum= '+add(l1)); ArrayList l2=new ArrayList(); l2.add(30.0); l2.add(40.0); System.out.println('displaying the sum= '+add(l2)); } } 

Výkon

 displaying the sum= 30.0 displaying the sum= 70.0 

Neohraničené zástupné znaky

Typ neobmedzeného zástupného znaku predstavuje zoznam neznámeho typu, ako napríklad Zoznam. Tento prístup môže byť užitočný v nasledujúcich situáciách: -

• Keď je daná metóda implementovaná pomocou funkcionality poskytovanej v triede Object.
• Keď generická trieda obsahuje metódy, ktoré nezávisia od parametra typu.

Príklad neobmedzených zástupných znakov

 import java.util.Arrays; import java.util.List; public class UnboundedWildcard { public static void display(List list) { for(Object o:list) { System.out.println(o); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); display(l1); List l2=Arrays.asList('One','Two','Three'); System.out.println('displaying the String values'); display(l2); } } 

Výkon

 displaying the Integer values 1 2 3 displaying the String values One Two Three 

Nižšie ohraničené zástupné znaky

Účelom zástupných znakov s dolnou hranicou je obmedziť neznámy typ na špecifický typ alebo nadtyp tohto typu. Používa sa deklarovaním zástupného znaku ('?'), za ktorým nasleduje kľúčové slovo super, za ktorým nasleduje jeho spodná hranica.

Syntax

 List 

Tu,

? je zástupný znak.

Super , je kľúčové slovo.

Celé číslo , je obalová trieda.

vba

Predpokladajme, že chceme napísať metódu pre zoznam Integer a jeho nadtyp (ako Number, Object). Použitím Zoznam je vhodný pre zoznam typu Integer alebo niektorú z jeho nadtried, zatiaľ čo Zoznam pracuje iba so zoznamom typu Integer. takže, Zoznam je menej obmedzujúce ako Zoznam .

Príklad dolného ohraničeného zástupného znaku

V tomto príklade používame zástupné znaky so spodnou hranicou na zapísanie metódy pre zoznam a zoznam.

 import java.util.Arrays; import java.util.List; public class LowerBoundWildcard { public static void addNumbers(List list) { for(Object n:list) { System.out.println(n); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); addNumbers(l1); List l2=Arrays.asList(1.0,2.0,3.0); System.out.println('displaying the Number values'); addNumbers(l2); } } 

Výkon

 displaying the Integer values 1 2 3 displaying the Number values 1.0 2.0 3.0