El Genèrics de Java La programació s'introdueix a J2SE 5 per tractar objectes segurs de tipus. Fa que el codi sigui estable detectant els errors en temps de compilació.

powershell major o igual

Abans dels genèrics, podem emmagatzemar qualsevol tipus d'objectes de la col·lecció, és a dir, no genèrics. Ara els genèrics obliguen el programador java a emmagatzemar un tipus específic d'objectes.

Avantatge dels genèrics Java

Hi ha principalment 3 avantatges dels genèrics. Són els següents:

1) Tipus de seguretat: Només podem contenir un sol tipus d'objectes en genèrics. No permet emmagatzemar altres objectes.

Sense genèrics, podem emmagatzemar qualsevol tipus d'objectes.

 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) No es requereix el tipus de fosa: No cal escriure l'objecte.

Abans dels genèrics, hem d'escriure 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) Comprovació en temps de compilació: Es comprova en temps de compilació, de manera que el problema no es produirà en temps d'execució. La bona estratègia de programació diu que és molt millor gestionar el problema en temps de compilació que en temps d'execució.

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

Sintaxi utilitzar la col·lecció genèrica

 ClassOrInterface 

Exemple per utilitzar els genèrics a Java

 ArrayList 

Exemple complet de genèrics a Java

Aquí, estem utilitzant la classe ArrayList, però podeu utilitzar qualsevol classe de col·lecció com ara 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()); } } } 

Sortida:

 element is: jai rahul jai 

Exemple de genèrics Java utilitzant Map

Ara farem servir elements del mapa amb genèrics. Aquí, hem de passar clau i valor. Entenem-ho amb un exemple senzill:

 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>

Sortida

java convertir char a int

 1 vijay 2 ankit 4 umesh 

Classe genèrica

Una classe que pot fer referència a qualsevol tipus es coneix com a classe genèrica. Aquí, estem utilitzant el paràmetre de tipus T per crear la classe genèrica d'un tipus específic.

Vegem un exemple senzill per crear i utilitzar la classe genèrica.

Creació d'una classe genèrica:

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

El tipus T indica que pot fer referència a qualsevol tipus (com String, Integer i Employee). El tipus que especifiqueu per a la classe s'utilitzarà per emmagatzemar i recuperar les dades.

Utilitzant classe genèrica:

Vegem el codi per utilitzar la classe genèrica.

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

Sortida

 2 

Tipus de paràmetres

Les convencions de denominació dels paràmetres de tipus són importants per aprendre genèrics a fons. Els paràmetres de tipus comuns són els següents:

hashtable java

1. T - Tipus
2. E - Element
3. K - Clau
4. N - Número
5. V - Valor

Mètode genèric

Igual que la classe genèrica, podem crear un mètode genèric que pot acceptar qualsevol tipus d'arguments. Aquí, l'abast dels arguments es limita al mètode on es declara. Permet mètodes estàtics i no estàtics.

Vegem un exemple senzill del mètode genèric de Java per imprimir elements de matriu. Estem utilitzant aquí I per indicar l'element.

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

Sortida

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

Comodí a Java Generics

El? El símbol (signe d'interrogació) representa l'element comodí. Significa qualsevol tipus. Si escrivim , vol dir qualsevol classe secundària de Number, per exemple, Integer, Float i double. Ara podem cridar el mètode de classe Number a través de qualsevol objecte de classe fill.

Podem utilitzar un comodí com a tipus de paràmetre, camp, tipus de retorn o variable local. Tanmateix, no es permet utilitzar un comodí com a argument de tipus per a una invocació de mètode genèric, la creació d'una instància de classe genèrica o un supertipus. .

Entenem-ho amb l'exemple que es dóna a continuació:

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

Sortida

 drawing rectangle drawing circle drawing circle 

Comodins amb límit superior

El propòsit dels comodins amb límit superior és disminuir les restriccions d'una variable. Restringeix el tipus desconegut perquè sigui un tipus específic o un subtipus d'aquest tipus. S'utilitza declarant el caràcter comodí ('?') seguit de la paraula clau extends (en cas de, classe) o implementa (en cas de, interfície), seguida del seu límit superior.

Sintaxi

 List 

Aquí,

? és un caràcter comodí.

tutorial de java

s'estén , és una paraula clau.

Número , és una classe present al paquet java.lang

Suposem que volem escriure el mètode per a la llista de Nombre i els seus subtipus (com Integer, Double). Utilitzant Llista és adequat per a una llista de tipus Number o qualsevol de les seves subclasses, mentre que Llista només funciona amb la llista de tipus Número. Tan, Llista és menys restrictiu que Llista .

Exemple de comodí de límit superior

En aquest exemple, estem utilitzant els comodins de límit superior per escriure el mètode per a Llista i Llista.

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

Sortida

 displaying the sum= 30.0 displaying the sum= 70.0 

Comodins il·limitats

El tipus de comodí sense límits representa la llista d'un tipus desconegut com ara Llista. Aquest enfocament pot ser útil en els escenaris següents: -

• Quan el mètode donat s'implementa utilitzant la funcionalitat proporcionada a la classe Object.
• Quan la classe genèrica conté els mètodes que no depenen del paràmetre tipus.

Exemple de comodins il·limitats

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

Sortida

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

Comodins amb límit inferior

El propòsit dels comodins amb límit inferior és restringir el tipus desconegut perquè sigui un tipus específic o un supertipus d'aquest tipus. S'utilitza declarant el caràcter comodí ('?') seguit de la paraula clau super, seguit del seu límit inferior.

Sintaxi

 List 

Aquí,

? és un caràcter comodí.

súper , és una paraula clau.

Enter , és una classe d'embolcall.

nbsp

Suposem que volem escriure el mètode per a la llista d'Enter i el seu supertipus (com Nombre, Objecte). Utilitzant Llista és adequat per a una llista de tipus Enter o qualsevol de les seves superclasses, mentre que Llista només funciona amb la llista de tipus Enter. Tan, Llista és menys restrictiu que Llista .

Exemple de comodí de límit inferior

En aquest exemple, estem utilitzant els comodins de límit inferior per escriure el mètode per a Llista i Llista.

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

Sortida

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