De Java Generics programmering introduceras i J2SE 5 för att hantera typsäkra objekt. Det gör koden stabil genom att detektera buggar vid kompilering.

uppdaterar java

Innan generika kan vi lagra alla typer av objekt i samlingen, d.v.s. icke-generiska. Generika tvingar nu java-programmeraren att lagra en specifik typ av objekt.

Fördelen med Java Generics

Det finns främst 3 fördelar med generika. De är följande:

1) Typsäkerhet: Vi kan bara hålla en enda typ av objekt i generika. Det tillåter inte att lagra andra föremål.

Utan Generics kan vi lagra alla typer av objekt.

 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) Typgjutning krävs inte: Det finns inget behov av att typcasta objektet.

Innan Generics måste vi skriva 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) Kontroll av kompileringstid: Det kontrolleras vid kompilering så problemet kommer inte att uppstå under körning. Den bra programmeringsstrategin säger att det är mycket bättre att hantera problemet vid kompileringstid än vid körning.

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

Syntax att använda generisk samling

 ClassOrInterface 

Exempel att använda Generics i java

 ArrayList 

Fullständigt exempel på generika i Java

Här använder vi ArrayList-klassen, men du kan använda vilken samlingsklass som helst som ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator etc.

 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()); } } } 

Produktion:

 element is: jai rahul jai 

Exempel på Java Generics som använder Map

Nu ska vi använda kartelement med generika. Här måste vi skicka nyckel och värde. Låt oss förstå det med ett enkelt exempel:

 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>

Produktion

objektklass i java

 1 vijay 2 ankit 4 umesh 

Generisk klass

En klass som kan referera till vilken typ som helst kallas en generisk klass. Här använder vi parametern T-typ för att skapa den generiska klassen av specifik typ.

Låt oss se ett enkelt exempel för att skapa och använda den generiska klassen.

Skapa en generisk klass:

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

T-typen indikerar att den kan referera till vilken typ som helst (som sträng, heltal och anställd). Typen du anger för klassen kommer att användas för att lagra och hämta data.

Använder generisk klass:

Låt oss se koden för att använda den generiska klassen.

 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()); }} 

Produktion

 2 

Typparametrar

Typparametrarnas namnkonventioner är viktiga för att lära sig generika grundligt. De vanliga typparametrarna är följande:

är lika med metod java

1. T - Typ
2. E - Element
3. K - Nyckel
4. N - Antal
5. V - Värde

Generisk metod

Liksom den generiska klassen kan vi skapa en generisk metod som kan acceptera alla typer av argument. Här är omfattningen av argument begränsad till metoden där den deklareras. Det tillåter statiska såväl som icke-statiska metoder.

Låt oss se ett enkelt exempel på en generisk java-metod för att skriva ut arrayelement. Vi använder här OCH för att beteckna elementet.

 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 ); } } 

Produktion

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

Jokertecken i Java Generics

Den ? (frågetecken) symbolen representerar jokerteckenelementet. Det betyder vilken typ som helst. Om vi ​​skriver betyder det vilken underordnad klass som helst av Number, t.ex. Integer, Float och double. Nu kan vi anropa metoden för Nummerklass genom vilket barnklassobjekt som helst.

Vi kan använda ett jokertecken som ett typ av en parameter, fält, returtyp eller lokal variabel. Det är dock inte tillåtet att använda ett jokertecken som ett typargument för en generisk metodanrop, en generisk klassinstans skapande eller en supertyp .

Låt oss förstå det med exemplet nedan:

 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); }} 

Produktion

 drawing rectangle drawing circle drawing circle 

Övre gränsade jokertecken

Syftet med övre gränsade jokertecken är att minska begränsningarna för en variabel. Den begränsar den okända typen till att vara en specifik typ eller en undertyp av den typen. Det används genom att deklarera jokertecken ('?') följt av nyckelordet extends (i fall av klass) eller implementerar (i fall av gränssnitt), följt av dess övre gräns.

Syntax

 List 

Här,

? är ett jokertecken.

sträcker sig , är ett nyckelord.

siffra , är en klass som finns i java.lang-paketet

Anta att vi vill skriva metoden för listan över Number och dess undertyper (som heltal, dubbel). Använder sig av Lista är lämplig för en lista med typnummer eller någon av dess underklasser medan Lista fungerar endast med listan över typ Number. Så, Lista är mindre restriktiv än Lista .

Exempel på övre gräns jokertecken

I det här exemplet använder vi jokertecken med övre gräns för att skriva metoden för List och List.

 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)); } } 

Produktion

 displaying the sum= 30.0 displaying the sum= 70.0 

Obegränsade jokertecken

Den obegränsade jokerteckentypen representerar listan över en okänd typ som List. Detta tillvägagångssätt kan vara användbart i följande scenarier: -

java delsträng

• När den givna metoden implementeras med hjälp av funktionaliteten i klassen Object.
• När den generiska klassen innehåller metoder som inte beror på typparametern.

Exempel på obegränsade jokertecken

 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); } } 

Produktion

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

Jokertecken med lägre gräns

Syftet med lägre gränsade jokertecken är att begränsa den okända typen till att vara en specifik typ eller en supertyp av den typen. Det används genom att deklarera jokertecken ('?') följt av supernyckelordet, följt av dess nedre gräns.

Syntax

 List 

Här,

? är ett jokertecken.

super , är ett nyckelord.

Heltal , är en omslagsklass.

tcp och ip-modell

Antag att vi vill skriva metoden för listan över heltal och dess supertyp (som Number, Object). Använder sig av Lista är lämplig för en lista av typen heltal eller någon av dess superklasser medan Lista fungerar endast med listan av typen heltal. Så, Lista är mindre restriktiv än Lista .

Exempel på lägre gräns jokertecken

I det här exemplet använder vi jokertecken med lägre gräns för att skriva metoden för List och List.

 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); } } 

Produktion

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