De Java Generics programmering er introdusert i J2SE 5 for å håndtere typesikre objekter. Det gjør koden stabil ved å oppdage feilene på kompileringstidspunktet.

c-program for todimensjonal array

Før generiske medisiner kan vi lagre alle typer objekter i samlingen, dvs. ikke-generiske. Nå tvinger generikk java-programmereren til å lagre en bestemt type objekter.

Fordelen med Java Generics

Det er hovedsakelig 3 fordeler med generika. De er som følger:

1) Type-sikkerhet: Vi kan bare holde en enkelt type objekter i generiske. Det tillater ikke å lagre andre gjenstander.

Uten Generics kan vi lagre alle typer objekter.

 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) Typestøping er ikke nødvendig: Det er ikke nødvendig å typecaste objektet.

Før Generics må vi skrive 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 kontrolleres ved kompilering, så problemet vil ikke oppstå under kjøring. Den gode programmeringsstrategien sier at det er langt bedre å håndtere problemet på kompileringstidspunktet enn kjøretid.

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

Syntaks å bruke generisk samling

 ClassOrInterface 

Eksempel å bruke Generics i java

 ArrayList 

Fullstendig eksempel på generikk i Java

Her bruker vi ArrayList-klassen, men du kan bruke hvilken som helst samlingsklasse 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()); } } } 

Produksjon:

 element is: jai rahul jai 

Eksempel på Java Generics som bruker Map

Nå skal vi bruke kartelementer ved hjelp av generikk. Her må vi gi nøkkel og verdi. La oss forstå det med et enkelt eksempel:

 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>

Produksjon

ascii tabell java

 1 vijay 2 ankit 4 umesh 

Generisk klasse

En klasse som kan referere til alle typer er kjent som en generisk klasse. Her bruker vi T-type-parameteren for å lage den generiske klassen av spesifikk type.

La oss se et enkelt eksempel for å lage og bruke den generiske klassen.

Opprette en generisk klasse:

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

T-typen indikerer at den kan referere til hvilken som helst type (som streng, heltall og ansatt). Typen du spesifiserer for klassen vil bli brukt til å lagre og hente dataene.

Bruker generisk klasse:

La oss se koden for å bruke den generiske 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()); }} 

Produksjon

 2 

Type parametere

Navnekonvensjonene for typeparametere er viktige for å lære generikk grundig. De vanlige typeparametrene er som følger:

er lik streng i java

1. T - Type
2. E - Element
3. K - Nøkkel
4. N - Antall
5. V - Verdi

Generisk metode

I likhet med den generiske klassen kan vi lage en generisk metode som kan akseptere alle typer argumenter. Her er omfanget av argumenter begrenset til metoden der det er deklarert. Det tillater statiske så vel som ikke-statiske metoder.

La oss se et enkelt eksempel på en generisk java-metode for å skrive ut array-elementer. Vi bruker her OG for å betegne 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 ); } } 

Produksjon

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

Jokertegn i Java Generics

Den ? (spørsmålstegn) symbolet representerer jokertegnelementet. Det betyr hvilken som helst type. Hvis vi skriver , betyr det en hvilken som helst underordnet klasse av tall, for eksempel heltall, flytende og dobbel. Nå kan vi kalle metoden for nummerklasse gjennom et hvilket som helst underordnet klasseobjekt.

Vi kan bruke et jokertegn som et type av en parameter, felt, returtype eller lokal variabel. Det er imidlertid ikke tillatt å bruke et jokertegn som et typeargument for en generisk metodeanrop, en generisk klasseforekomstopprettelse eller en supertype .

La oss forstå det med eksemplet nedenfor:

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

Produksjon

 drawing rectangle drawing circle drawing circle 

Jokertegn med øvre grense

Formålet med øvre grenser for jokertegn er å redusere restriksjonene på en variabel. Den begrenser den ukjente typen til å være en spesifikk type eller en undertype av den typen. Det brukes ved å deklarere jokertegn ('?') etterfulgt av utvides (i tilfelle av, klasse) eller implementerer (i tilfelle, grensesnitt) nøkkelordet, etterfulgt av dets øvre grense.

Syntaks

 List 

Her,

? er et jokertegn.

strekker , er et nøkkelord.

Antall , er en klasse til stede i java.lang-pakken

Anta at vi ønsker å skrive metoden for listen over tall og dens undertyper (som heltall, dobbel). Ved hjelp av Liste er egnet for en liste over type Number eller noen av dets underklasser mens Liste fungerer kun med listen over type Number. Så, Liste er mindre restriktiv enn Liste .

tallene i alfabetet

Eksempel på øvre grense-jokertegn

I dette eksemplet bruker vi jokertegnene med øvre grense for å skrive metoden for List og 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)); } } 

Produksjon

 displaying the sum= 30.0 displaying the sum= 70.0 

Ubegrensede jokertegn

Den ubegrensede jokertegntypen representerer listen over en ukjent type, for eksempel List. Denne tilnærmingen kan være nyttig i følgende scenarier: -

• Når den gitte metoden er implementert ved å bruke funksjonaliteten i Object-klassen.
• Når den generiske klassen inneholder metodene som ikke avhenger av typeparameteren.

Eksempel på ubundne jokertegn

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

Produksjon

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

Jokertegn med nedre grense

Formålet med jokertegn med lavere grenser er å begrense den ukjente typen til å være en spesifikk type eller en supertype av den typen. Det brukes ved å deklarere jokertegn ('?') etterfulgt av supernøkkelordet, etterfulgt av dets nedre grense.

Syntaks

 List 

Her,

? er et jokertegn.

super , er et nøkkelord.

Heltall , er en innpakningsklasse.

gyldige identifikatorer i java

Anta at vi vil skrive metoden for listen over heltall og dens supertype (som tall, objekt). Ved hjelp av Liste er egnet for en liste av typen Heltall eller noen av dens superklasser mens Liste fungerer kun med listen av typen heltall. Så, Liste er mindre restriktiv enn Liste .

Eksempel på jokertegn for nedre grense

I dette eksemplet bruker vi jokertegnene med nedre grense for å skrive metoden for List og 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); } } 

Produksjon

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