Menú

Tutorial de Java Generics amb exemples

java generics tutorial with examples

Proveu El Nostre Instrument Per Eliminar Problemes

Java Generics és un conjunt de funcions que us permeten escriure codi independentment del tipus de dades. En aquest article s'explica el detall de Java Generics amb exemples:

Els genèrics són una de les funcions importants de Java i es van introduir a partir de Java 5.

Per definició, els genèrics són un conjunt de funcions del llenguatge Java que permeten al programador utilitzar tipus i funcions genèriques i, per tant, garantir la seguretat dels tipus.

Java Generics

Què aprendreu:

Com funcionen els genèrics a Java?

Si ja heu treballat amb C ++, Java Generics és el mateix que les plantilles de C ++. Java Generics us permet incloure un paràmetre a la definició de classe / mètode que tindrà el valor d’un tipus de dades primitiu.

Per exemple, podeu tenir una classe genèrica 'Matriu' de la següent manera:

Class Array {….}

On és el tipus parametritzat.

A continuació, podeu crear objectes per a aquesta classe de la següent manera:

Array int_array = new Array () Array char_array = new Array ();

Per tant, donada una classe parametritzada genèrica, podeu crear objectes de la mateixa classe amb diferents tipus de dades com a paràmetres. Aquesta és l’essència principal de l’ús de Java Generics.

De la mateixa manera, podeu escriure un mètode genèric amb un tipus parametritzat per ordenar una matriu i, a continuació, instanciar aquest mètode a qualsevol tipus primitiu.

millors netejadors de registre per a Windows 10

Java Generics s’utilitza principalment amb el marc de col·leccions de Java. Les diferents col·leccions com LinkedList, List, Map, HashMap, etc. utilitzen genèrics per a la implementació. Els genèrics proporcionen seguretat de tipus ja que la comprovació de tipus es fa en temps de compilació, cosa que fa que el vostre codi sigui més estable.

Analitzem ara els detalls de les classes i mètodes genèrics, així com d'altres temes relacionats.

Classes genèriques

Una classe genèrica és la mateixa que una classe normal, tret que el nom de la classe va seguit d'un tipus entre claudàtors angulars.

La definició general d'una classe genèrica és la següent:

classe nom_classe
{
variables de classe;
... ..
mètodes de classe;
}

Un cop definida la classe, podeu crear objectes de qualsevol tipus de dades que vulgueu de la manera següent:

class_name obj = new class_name ();

Per exemple, per a l'objecte Integer, la declaració serà:

class_name obj = new class_name;

De la mateixa manera, per al tipus de dades String, l'objecte serà:

class_name str_Obj = new class_name;

A continuació es mostra un exemple d’implementació per a la classe Generic.

class MyGenericClass { T obj; void add(T obj) { this.obj=obj; } T get() { return obj; } } class Main { public static void main(String args()) { MyGenericClass m_int=new MyGenericClass(); m_int.add(2); MyGenericClassmstr=new MyGenericClass(); mstr.add('SoftwaretestingHelp'); System.out.println('Member of MyGenericClass:' + m_int.get()); System.out.println('Member of MyGenericClass:' + mstr.get()); } }

Sortida:

Implementació per a la sortida de classes genèriques

Al programa anterior, una classe MyGenericClass és una classe genèrica. Té dos mètodes, és a dir, afegir i obtenir. El mètode add inicialitza l'objecte genèric mentre els mètodes get retornen l'objecte.

A la funció principal, declarem dos objectes de tipus Integer i String cadascun. Inicialitzem aquests dos objectes amb els seus respectius valors inicials mitjançant el mètode add i, a continuació, generem el contingut d’aquests objectes mitjançant el mètode get.

Vam presentar l'exemple de classe genèrica anterior amb un paràmetre de tipus. Però, en realitat, una classe també pot tenir més d’un paràmetre de tipus. En aquest cas, els paràmetres de tipus estan separats per una coma.

L'exemple següent ho demostra:

classTest_Generics { T1 obj1; // An object of type T1 T2 obj2; // An object of type T2 // constructor to initialise T1 & T2 objects Test_Generics(T1 obj1, T2 obj2) { this.obj1 = obj1; this.obj2 = obj2; } public void print() { System.out.println('T1 Object:' + obj1); System.out.println('T2 Object:' + obj2); } } class Main { public static void main (String() args) { Test_Genericsobj = newTest_Generics('Java Generics', 1); obj.print(); } }

Sortida:

Escriviu els paràmetres de sortida

En aquest programa, tenim dos paràmetres tipus, és a dir, T1 i T2. Tenim funcions per inicialitzar els objectes membres i també per imprimir el contingut. A la funció principal, declarem un objecte amb dos tipus, és a dir, String i Integer. La sortida del programa mostra el contingut de l'objecte creat.

Igual que les classes, també podeu tenir interfícies genèriques. Aprendrem tot sobre les interfícies en un tema separat.

Mètodes genèrics de Java

De la mateixa manera que podeu tenir classes i interfícies genèriques, també podeu tenir mètodes genèrics en cas que no necessiteu tota una classe per ser genèric.

El programa següent mostra la implementació del mètode genèric “printGenericArray”. Tingueu en compte la crida del mètode a la funció principal. Aquí fem dues trucades al mètode genèric, primer amb tipus i després amb tipus.

public class Main{ public static void printGenericArray(T() items) { for ( T item : items){ System.out.print(item + ' '); } System.out.println(); } public static void main( String args() ) { Integer() int_Array = { 1, 3, 5, 7, 9, 11 }; Character() char_Array = { 'J', 'A', 'V', 'A', 'T','U','T','O','R','I','A', 'L','S' }; System.out.println( 'Integer Array contents:' ); printGenericArray(int_Array ); System.out.println( 'Character Array contents:' ); printGenericArray(char_Array ); } }

Sortida:

Sortida de mètodes genèrics

Paràmetres de tipus acotats

Els paràmetres de tipus acotats apareixen quan es volen limitar els tipus de dades a Genèrics. Per exemple, si voleu una classe o mètode genèric particular o qualsevol interfície que només funcioni per als tipus de dades numèriques, podeu especificar-ho mitjançant la paraula clau 'estén'.

Això es mostra a continuació:

List myList = new ArrayList(); List list1 = new ArrayList();

El compilador acceptarà les dues declaracions anteriors, ja que Long i Integer són subclasses de Number.

La següent declaració, però, serà un problema.

List list = new ArrayList();

Això donarà un error en temps de compilació perquè la cadena no és un número. El símbol '?' De l'exemple anterior es coneix com a comodí i el parlarem a continuació.

Per tant, en general, els paràmetres de tipus acotats s’utilitzen principalment quan voleu restringir els tipus de dades que s’utilitzaran al vostre codi genèric.

Comodí Java Generics

A Java, un comodí es denota amb un signe d’interrogació ‘?’ Que s’utilitza per referir-se a un tipus desconegut. Els comodins s’utilitzen principalment amb genèrics com a tipus de paràmetre.

Quan utilitzeu comodins genèrics, heu de recordar un punt que, tot i que l’objecte és la superclasse de la resta de classes, la col·lecció d’objectes ( Per exemple, Llista) no és una superclasse de la resta de col·leccions.

A part d’utilitzar-se com a tipus de paràmetre, podeu utilitzar un comodí com a camp, com a variable local i com a tal. Tanmateix, mai no podeu utilitzar un comodí com a supertipus, ni com a argument de tipus per invocar un mètode genèric o en cas de creació d'una instància d'una classe genèrica.

Hi ha molts exemples de tipus de comodins parametritzats (aquí com a mínim un argument de tipus és un comodí) com es mostra a continuació i els comodins que s’utilitzen en diferents llocs s’interpretaran de manera diferent:

  • Col · lecció La col·lecció indica tota instància de la interfície de col·lecció, independentment de l'argument de tipus utilitzat.
  • Llista : La llista representa tots els tipus de llista on el tipus d’element serà un número.
  • Comparador: Totes les instàncies de la interfície de comparació per a arguments de tipus que són Stringsupertypes.

Tingueu en compte que un tipus de comodí és una regla que s’imposa per reconèixer els tipus vàlids. No és un tipus de dades concret. Els comodins genèrics es poden limitar o no.

# 1) Comodins sense límits

Als comodins sense límits, no hi ha restriccions en les variables de tipus i es denota de la manera següent:

ArrayList mylist = new ArrayList(); ArrayList my_strList = new ArrayList();

# 2) Comodins delimitats

Ja hem parlat dels tipus acotats. Això posa restriccions al tipus de dades que s’utilitza per instanciar els paràmetres del tipus mitjançant les paraules clau - extends o super. Aquests comodins es poden dividir en comodins amb límits superiors i comodins amb límits inferiors.

  • Comodins superiors delimitats

Si voleu que l'expressió genèrica sigui vàlida per a totes les subclasses d'un tipus determinat, heu d'especificar el comodí delimitat superior amb la paraula clau extesa.

Per exemple, suposem que necessiteu un mètode genèric que admeti Llista, Llista, etc., llavors podeu especificar un comodí delimitat superior Llista . Com que Number és una superclasse, aquest mètode genèric funcionarà per a totes les seves subclases.

El programa següent ho demostra.

importjava.util.*; public class Main { private static Number summation (List numbers){ double sum = 0.0; for (Number n : numbers) sum += n.doubleValue(); return sum; } public static void main(String() args) { //Number subtype : Integer Listint_list = Arrays.asList(1,3,5,7,9); System.out.println('Sum of the elements in int_list:' + summation(int_list)); //Number subtype : Double List doubles_list = Arrays.asList(1.0,1.5,2.0,2.5,3.0,3.5); System.out.println('Sum of the elements in doubles_list:' + summation(doubles_list)); } }

Sortida:

Sortida de comodins superiors delimitats

Aquí hem proporcionat un comodí de límit superior, Llista de l'argument tipus de la funció 'suma'. A la funció principal, definim dues llistes, és a dir, int_list de tipus enter i doubles_list de tipus Double. Com que Enter i Double són les subclasses de Number, la suma de funcions funciona perfectament en aquestes dues llistes.

  • Comodins delimitats inferiorment

Si voleu que l'expressió genèrica accepti totes les superclasses d'un tipus concret, podeu especificar un comodí delimitat inferior per al vostre argument de tipus.

quin no és un dels tipus d’elements que es prova durant la prova del sistema?

A continuació es dóna un exemple d’implementació per a això:

importjava.util.*; class Main { public static void main(String() args) { //Integer List ListInt_list= Arrays.asList(1,3,5,7); System.out.print('Integer List:'); printforLowerBoundedWildcards(Int_list); //Number list ListNumber_list= Arrays.asList(2,4,6,8); System.out.print('Number List:'); printforLowerBoundedWildcards(Number_list); } public static void printforLowerBoundedWildcards(List list) { System.out.println(list); } }

Sortida:

Sortides de comodins delimitats més avall

En aquest programa, el caràcter comodí inferior delimitat especificat és 'Llista'. A continuació, a la funció principal, tenim una llista de tipus i la llista. Com hem utilitzat el comodí inferior delimitat, la classe Number és una superclasse d'Integer és un argument de tipus vàlid.

Avantatges de Java Generics

# 1) Tipus de seguretat

Els genèrics garanteixen la seguretat del tipus. Això significa que la comprovació de tipus es fa en temps de compilació en lloc de fer-ho. Per tant, no hi ha possibilitat d'obtenir 'ClassCastException' durant l'execució, ja que s'utilitzaran tipus correctes.

importjava.util.*; class Main { public static void main(String() args) { List mylist = new ArrayList(); mylist.add(10); mylist.add('10'); System.out.println(mylist); List list = new ArrayList(); list.add(10); list.add('10');// compile-time error System.out.println(list); } }

Al programa anterior, tenim dues llistes, una sense genèrics i una altra amb genèrics. A la llista no genèrica, no hi ha cap tipus de seguretat. Podeu afegir un enter, una cadena, etc. com a element i s’accepta.

A la llista genèrica, només podeu afegir un tipus d'element que s'especifica a l'expressió genèrica. Si intenteu afegir un element d’un altre tipus, donarà lloc a un error de compilació.

Al programa anterior, l'error de temps de compilació apareix a la línia:

list.add('10');

# 2) Reutilització del codi

Amb Generics, no cal escriure codi separat per a cada tipus de dades. Podeu escriure una sola classe o mètode, etc. i utilitzar-lo per a tots els tipus de dades.

# 3) No cal fer prediccions

Com utilitzeu Generics, el compilador coneix els tipus que s’utilitzen i, per tant, no hi ha necessitat de tipografia.

copiar matriu a una altra matriu java

Penseu en el codi següent:

List mylist = new ArrayList(); mylist.add('Java'); String mystr = (String) list.get(0); //typecasting required

Com podeu veure quan s’utilitza una llista normal, heu d’escriure l’element de la llista al tipus adequat de la manera que es fa per al mystr anterior.

Ara tornem a escriure el mateix codi amb una llista genèrica.

List list = new ArrayList(); list.add('Java'); String mystr = list.get(0);

Aquí hem especificat el tipus de cadena com a expressió genèrica per a la declaració de llista. Per tant, per recuperar elements individuals d’aquesta llista, no necessitem tipografia.

# 4) Implementar algorismes genèrics

Podeu implementar molts més algorismes genèrics quan utilitzeu Generics per codificar.

# 5) Comprovació del temps de compilació

Com ja s'ha esmentat, quan utilitzeu Generics al vostre programa Java, el compilador comprova els tipus en el moment de la compilació, evitant així la finalització anormal del programa en temps d'execució.

Preguntes freqüents

P # 1) Per què fem servir Generics a Java?

Resposta: Els genèrics garanteixen la independència del tipus, és a dir, podem proporcionar un paràmetre de tipus mentre es defineix una classe / interfície / mètode, etc., de manera que durant la instantània real podem especificar el tipus real. D’aquesta manera, també proporcionem la reutilització del codi.

P # 2) Els genèrics són importants a Java?

Resposta: Sí. De fet, els genèrics són les característiques més importants de Java per garantir la seguretat del tipus, és a dir, la comprovació del tipus en temps de compilació.

P # 3) Quan va afegir Java Generics?

Resposta: Els genèrics es van afegir a Java el 2004 amb J2SE 5.0 amb la intenció de garantir la seguretat del tipus de compilació a Java.

Q # 4) Què és un tipus genèric?

Resposta: Un tipus genèric és una classe genèrica, una interfície o un mètode que es proporciona amb un paràmetre tipus. Això permet la seguretat del tipus i la reutilització del codi.

P # 5) Podem utilitzar Generics amb Array a Java?

Resposta: No. Java no permet matrius genèrics.

Conclusió

D’aquesta manera es conclou el tutorial sobre els genèrics Java, que es considera una de les funcions més importants de les versions recents de Java. L’ús de Generics als programes Java garanteix la seguretat dels tipus i la reutilització del codi. També garanteix la comprovació del temps de compilació perquè el programa no es trenqui en temps d'execució.

Els genèrics Java són útils sobretot amb la interfície de col·leccions Java, que parlarem detalladament en un altre tutorial d’aquesta sèrie.

Bona lectura !!

Lectura recomanada

^