generice mijloace tipuri parametrizate . Ideea este de a permite tipului (întreg, șir, etc. și tipuri definite de utilizator) să fie un parametru pentru metode, clase și interfețe. Folosind generice, este posibil să creați clase care funcționează cu diferite tipuri de date. O entitate cum ar fi o clasă, o interfață sau o metodă care operează pe un tip parametrizat este o entitate generică.
De ce generice?
The Obiect este superclasa tuturor celorlalte clase, iar referința la obiect se poate referi la orice obiect. Aceste caracteristici nu au siguranța de tip. Genericele adaugă acest tip de caracteristică de siguranță. Vom discuta acest tip de caracteristică de siguranță în exemplele ulterioare.
Genericurile din Java sunt similare cu șabloanele din C++. De exemplu, clase precum HashSet, ArrayList, HashMap etc., folosesc generice foarte bine. Există unele diferențe fundamentale între cele două abordări ale tipurilor generice.
Tipuri de generice Java
Metoda generică: Metoda generică Java preia un parametru și returnează o anumită valoare după efectuarea unei sarcini. Este exact ca o funcție normală, totuși, o metodă generică are parametri de tip care sunt citați după tipul actual. Acest lucru permite ca metoda generică să fie utilizată într-un mod mai general. Compilatorul are grijă de tipul de siguranță care permite programatorilor să codifice cu ușurință, deoarece nu trebuie să efectueze turnări lungi, individuale.
Clase generice: O clasă generică este implementată exact ca o clasă non-generică. Singura diferență este că conține o secțiune de parametri de tip. Pot exista mai mult de un tip de parametru, despărțiți prin virgulă. Clasele, care acceptă unul sau mai mulți parametri, sunt cunoscute ca clase parametrizate sau tipuri parametrizate.
Clasa generică
Ca și C++, folosim pentru a specifica tipurile de parametri în crearea clasei generice. Pentru a crea obiecte dintr-o clasă generică, folosim următoarea sintaxă.
// To create an instance of generic class BaseType obj = new BaseType ()>
Notă: În Tipul de parametru nu putem folosi primitive precum „int”, „char” sau „double”.
Java
// Java program to show working of user defined> // Generic classes> // We use to specify Parameter type> class> Test {> >// An object of type T is declared> >T obj;> >Test(T obj) {>this>.obj = obj; }>// constructor> >public> T getObject() {>return> this>.obj; }> }> // Driver class to test above> class> Main {> >public> static> void> main(String[] args)> >{> >// instance of Integer type> >Test iObj =>new> Test(>15>);> >System.out.println(iObj.getObject());> >// instance of String type> >Test sObj> >=>new> Test(>'GeeksForGeeks'>);> >System.out.println(sObj.getObject());> >}> }> |
>
>Ieșire
15 GeeksForGeeks>
De asemenea, putem trece mai mulți parametri de tip în clasele generice.
Java
Powershell comentariu multilinie
// Java program to show multiple> // type parameters in Java Generics> // We use to specify Parameter type> class> Test> {> >T obj1;>// An object of type T> >U obj2;>// An object of type U> >// constructor> >Test(T obj1, U obj2)> >{> >this>.obj1 = obj1;> >this>.obj2 = obj2;> >}> >// To print objects of T and U> >public> void> print()> >{> >System.out.println(obj1);> >System.out.println(obj2);> >}> }> // Driver class to test above> class> Main> {> >public> static> void> main (String[] args)> >{> >Test obj => >new> Test(>'GfG'>,>15>);> >obj.print();> >}> }> |
>
>Ieșire
GfG 15>
Funcții generice:
De asemenea, putem scrie funcții generice care pot fi apelate cu diferite tipuri de argumente în funcție de tipul de argumente transmise metodei generice. Compilatorul se ocupă de fiecare metodă.
Java
// Java program to show working of user defined> // Generic functions> class> Test {> >// A Generic method example> >static> >void> genericDisplay(T element)> >{> >System.out.println(element.getClass().getName()> >+>' = '> + element);> >}> >// Driver method> >public> static> void> main(String[] args)> >{> >// Calling generic method with Integer argument> >genericDisplay(>11>);> >// Calling generic method with String argument> >genericDisplay(>'GeeksForGeeks'>);> >// Calling generic method with double argument> >genericDisplay(>1.0>);> >}> }> |
>
varsta salman khan khan
>Ieșire
java.lang.Integer = 11 java.lang.String = GeeksForGeeks java.lang.Double = 1.0>
Genericele funcționează numai cu tipuri de referință:
Când declarăm o instanță a unui tip generic, argumentul tip transmis parametrului tip trebuie să fie un tip de referință. Nu putem folosi tipuri de date primitive precum int , char.
Test obj = new Test(20);>
Linia de mai sus are ca rezultat o eroare la timp de compilare care poate fi rezolvată folosind pachete de tip pentru a încapsula un tip primitiv.
Dar tablourile de tip primitiv pot fi trecute la parametrul de tip deoarece tablourile sunt tipuri de referință.
ArrayList a = new ArrayList();>
Tipurile generice diferă în funcție de argumentele tipului lor:
Luați în considerare următorul cod Java.
Java
// Java program to show working> // of user-defined Generic classes> // We use to specify Parameter type> class> Test {> >// An object of type T is declared> >T obj;> >Test(T obj) {>this>.obj = obj; }>// constructor> >public> T getObject() {>return> this>.obj; }> }> // Driver class to test above> class> Main {> >public> static> void> main(String[] args)> >{> >// instance of Integer type> >Test iObj =>new> Test(>15>);> >System.out.println(iObj.getObject());> >// instance of String type> >Test sObj> >=>new> Test(>'GeeksForGeeks'>);> >System.out.println(sObj.getObject());> >iObj = sObj;>// This results an error> >}> }> |
>
>
Ieșire:
error: incompatible types: Test cannot be converted to Test>
Chiar dacă iObj și sObj sunt de tip Test, ele sunt referințe la diferite tipuri, deoarece parametrii lor de tip diferă. Genericurile adaugă siguranța tipului prin aceasta și previn erorile.
Tastați parametri în Java Generics
Convențiile de denumire a parametrilor de tip sunt importante pentru a învăța temeinic genericele. Parametrii de tip comun sunt următorii:
100 km/h în mph
- T – Tip
- E – Element
- K – Cheie
- N – Număr
- V – Valoare
Avantajele genericelor:
Programele care folosesc generice au multe beneficii față de codul non-generic.
1. Reutilizarea codului: Putem scrie o metodă/clasă/interfață o dată și o putem folosi pentru orice tip dorim.
2. Tip de siguranță: Genericurile fac erori să apară în timpul compilării decât în timpul rulării (este întotdeauna mai bine să cunoașteți problemele din codul dvs. în timpul compilării, decât să faceți codul să eșueze în timpul rulării). Să presupunem că doriți să creați un ArrayList care să stocheze numele studenților, iar dacă din greșeală programatorul adaugă un obiect întreg în loc de un șir, compilatorul o permite. Dar, când recuperăm aceste date din ArrayList, provoacă probleme în timpul execuției.
Java
// Java program to demonstrate that NOT using> // generics can cause run time exceptions> import> java.util.*;> class> Test> {> >public> static> void> main(String[] args)> >{> >// Creatinga an ArrayList without any type specified> >ArrayList al =>new> ArrayList();> >al.add(>'Sachin'>);> >al.add(>'Rahul'>);> >al.add(>10>);>// Compiler allows this> >String s1 = (String)al.get(>0>);> >String s2 = (String)al.get(>1>);> >// Causes Runtime Exception> >String s3 = (String)al.get(>2>);> >}> }> |
>
>
Ieșire:
Exception in thread 'main' java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at Test.main(Test.java:19)>
Cum rezolvă genericii această problemă?
Când definim ArrayList, putem specifica că această listă poate lua numai obiecte String.
Java
java sort arraylist
// Using Java Generics converts run time exceptions into> // compile time exception.> import> java.util.*;> class> Test> {> >public> static> void> main(String[] args)> >{> >// Creating a an ArrayList with String specified> >ArrayList al =>new> ArrayList ();> >al.add(>'Sachin'>);> >al.add(>'Rahul'>);> >// Now Compiler doesn't allow this> >al.add(>10>);> >String s1 = (String)al.get(>0>);> >String s2 = (String)al.get(>1>);> >String s3 = (String)al.get(>2>);> >}> }> |
>
>
Ieșire:
15: error: no suitable method found for add(int) al.add(10); ^>
3. Turnarea de tip individual nu este necesară: Dacă nu folosim generice, atunci, în exemplul de mai sus, de fiecare dată când recuperăm date din ArrayList, trebuie să le tipărim. Tastatura la fiecare operațiune de recuperare este o mare durere de cap. Dacă știm deja că lista noastră conține doar date șir, nu trebuie să le scriem de fiecare dată.
Java
// We don't need to typecast individual members of ArrayList> import> java.util.*;> class> Test {> >public> static> void> main(String[] args)> >{> >// Creating a an ArrayList with String specified> >ArrayList al =>new> ArrayList();> >al.add(>'Sachin'>);> >al.add(>'Rahul'>);> >// Typecasting is not needed> >String s1 = al.get(>0>);> >String s2 = al.get(>1>);> >}> }> |
>
>
4. Generics promovează reutilizarea codului: Cu ajutorul genericelor în Java, putem scrie cod care va funcționa cu diferite tipuri de date. De exemplu,
Să presupunem că vrem să sortăm elementele matricei de diferite tipuri de date, cum ar fi int, char, String etc.
Practic, vom avea nevoie de diferite funcții pentru diferite tipuri de date.
Pentru simplitate, vom folosi sortarea cu bule.
Dar prin folosire generice, putem realiza caracteristica de reutilizare a codului.
Java
public> class> GFG {> >public> static> void> main(String[] args)> >{> >Integer[] a = {>100>,>22>,>58>,>41>,>6>,>50> };> >Character[] c = {>'v'>,>'g'>,>'a'>,>'c'>,>'x'>,>'d'>,>'t'> };> >String[] s = {>'Virat'>,>'Rohit'>,>'Abhinay'>,>'Chandu'>,>'Sam'>,>'Bharat'>,>'Kalam'> };> >System.out.print(>'Sorted Integer array : '>);> >sort_generics(a);> >System.out.print(>'Sorted Character array : '>);> >sort_generics(c);> >System.out.print(>'Sorted String array : '>);> >sort_generics(s);> > >}> >public> static> extends Comparable>void sort_generics(T[] a) { //Pe măsură ce comparăm tipurile de date neprimitive //trebuie să folosim clasa comparabilă //Bubble Sort logic for (int i = 0; i 1; i++) { for (int j = 0; j 1; j++) { if (a[j].compareTo(a[j + 1])> 0) { swap(j, j + 1, a); } } } // Tipărirea elementelor după sortat pentru (T i : a) { System.out.print(i + ', '); } System.out.println(); } public static void swap(int i, int j, T[] a) { T t = a[i]; a[i] = a[j]; a[j] = t; } }>>> |
>linie nouă python