Merkloos product middelen geparametriseerde typen . Het idee is om toe te staan dat type (Integer, String, … enz., en door de gebruiker gedefinieerde typen) een parameter kan zijn voor methoden, klassen en interfaces. Met Generics is het mogelijk klassen te maken die met verschillende gegevenstypen werken. Een entiteit zoals een klasse, interface of methode die op een geparametriseerd type werkt, is een generieke entiteit.
Waarom generieke geneesmiddelen?
De Voorwerp is de superklasse van alle andere klassen, en Objectreferentie kan naar elk object verwijzen. Deze functies missen typeveiligheid. Generieke geneesmiddelen voegen dat soort veiligheidsfunctie toe. We zullen dat type veiligheidsvoorziening in latere voorbeelden bespreken.
Generieken in Java zijn vergelijkbaar met sjablonen in C++. Klassen als HashSet, ArrayList, HashMap, enz. maken bijvoorbeeld heel goed gebruik van generieke geneesmiddelen. Er zijn enkele fundamentele verschillen tussen de twee benaderingen van generieke typen.
Soorten Java-generieken
Generieke methode: De algemene Java-methode neemt een parameter en retourneert een bepaalde waarde na het uitvoeren van een taak. Het is precies hetzelfde als een normale functie, maar een generieke methode heeft typeparameters die worden geciteerd door het daadwerkelijke type. Hierdoor kan de generieke methode op een meer algemene manier worden gebruikt. De compiler zorgt voor het soort veiligheid waardoor programmeurs gemakkelijk kunnen coderen, omdat ze geen lange, individuele typecasts hoeven uit te voeren.
Generieke klassen: Een generieke klasse wordt op precies dezelfde manier geïmplementeerd als een niet-generieke klasse. Het enige verschil is dat het een typeparametersectie bevat. Er kan meer dan één type parameter zijn, gescheiden door een komma. De klassen, die een of meer parameters accepteren, staan bekend als geparametriseerde klassen of geparametriseerde typen.
Generieke klasse
Net als C++ gebruiken we om parametertypen te specificeren bij het maken van generieke klassen. Om objecten van een generieke klasse te maken, gebruiken we de volgende syntaxis.
// To create an instance of generic class BaseType obj = new BaseType ()>
Opmerking: In Parametertype kunnen we geen primitieven zoals ‘int’, ‘char’ of ‘double’ gebruiken.
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());> >}> }> |
>
>Uitvoer
15 GeeksForGeeks>
We kunnen ook meerdere Type-parameters doorgeven in algemene klassen.
Java
shellscript uitvoerbaar maken
// 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();> >}> }> |
>
>Uitvoer
Linux voer cmd uit
GfG 15>
Generieke functies:
We kunnen ook generieke functies schrijven die kunnen worden aangeroepen met verschillende soorten argumenten, gebaseerd op het type argumenten dat aan de generieke methode wordt doorgegeven. De compiler verwerkt elke methode.
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>);> >}> }> |
>
>Uitvoer
java.lang.Integer = 11 java.lang.String = GeeksForGeeks java.lang.Double = 1.0>
Generieke geneesmiddelen werken alleen met referentietypen:
Wanneer we een instantie van een generiek type declareren, moet het type-argument dat aan de parameter type wordt doorgegeven een referentietype zijn. We kunnen geen primitieve gegevenstypen gebruiken, zoals int , verkoold.
Test obj = new Test(20);>
De bovenstaande regel resulteert in een compileerfout die kan worden opgelost met behulp van type wrappers om een primitief type in te kapselen.
Maar arrays van het primitieve type kunnen worden doorgegeven aan de parameter type, omdat arrays referentietypen zijn.
ArrayList a = new ArrayList();>
Generieke typen verschillen op basis van hun typeargumenten:
Beschouw de volgende Java-code.
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> >}> }> |
>
>
Uitgang:
error: incompatible types: Test cannot be converted to Test>
Ook al zijn iObj en sObj van het type Test, het zijn verwijzingen naar verschillende typen omdat hun typeparameters verschillen. Generieken voegen hierdoor typeveiligheid toe en voorkomen fouten.
Typ parameters in Java-generieken
De naamgevingsconventies voor typeparameters zijn belangrijk om generieke geneesmiddelen grondig te leren. De algemene typeparameters zijn als volgt:
java arraylist sorteren
- T – Type
- E – Element
- K – Sleutel
- N – Nummer
- V – Waarde
Voordelen van generieke geneesmiddelen:
Programma's die generieke code gebruiken, hebben veel voordelen ten opzichte van niet-generieke code.
1. Codehergebruik: We kunnen een methode/klasse/interface één keer schrijven en deze gebruiken voor elk type dat we willen.
2. Typeveiligheid: Generics maken fouten om tijdens het compileren te verschijnen dan tijdens runtime (het is altijd beter om problemen in uw code tijdens het compileren te kennen in plaats van uw code tijdens runtime te laten mislukken). Stel dat u een ArrayList wilt maken waarin de namen van studenten worden opgeslagen, en als de programmeur per ongeluk een geheel getalobject toevoegt in plaats van een string, staat de compiler dit toe. Maar wanneer we deze gegevens uit ArrayList ophalen, veroorzaakt dit problemen tijdens runtime.
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>);> >}> }> |
>
iteratie van de kaart in Java
>
Uitgang:
Exception in thread 'main' java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at Test.main(Test.java:19)>
Hoe lossen generieke geneesmiddelen dit probleem op?
Bij het definiëren van ArrayList kunnen we opgeven dat deze lijst alleen String-objecten kan bevatten.
Java
// 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>);> >}> }> |
>
>
Uitgang:
15: error: no suitable method found for add(int) al.add(10); ^>
3. Individueel gieten is niet nodig: Als we geen generieke geneesmiddelen gebruiken, moeten we in het bovenstaande voorbeeld elke keer dat we gegevens uit ArrayList ophalen, deze typen. Typecasting bij elke ophaaloperatie is een grote hoofdpijn. Als we al weten dat onze lijst alleen stringgegevens bevat, hoeven we deze niet elke keer te typen.
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. Generieke geneesmiddelen bevorderen de herbruikbaarheid van code: Met behulp van generieke geneesmiddelen in Java kunnen we code schrijven die met verschillende soorten gegevens werkt. Bijvoorbeeld,
Laten we zeggen dat we de array-elementen van verschillende gegevenstypen zoals int, char, String etc. willen sorteren.
In principe hebben we verschillende functies nodig voor verschillende gegevenstypen.
Voor de eenvoud zullen we Bubble-sortering gebruiken.
Maar door te gebruiken Merkloos product, we kunnen de functie voor herbruikbaarheid van code realiseren.
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) {//Terwijl we de niet-primitieve gegevenstypen vergelijken //we moeten een vergelijkbare klasse gebruiken //Bubble Sort-logica voor (int i = 0; i 1; i++) { for (int j = 0; j 1; j++) { als (a[j].vergelijk(a[j + 1])> 0) { ruil(j, j + 1, a); } } } // De elementen afdrukken nadat ze zijn gesorteerd op (T i: a) { System.out.print(i + ', '); } Systeem.out.println(); } openbare statische leegte-swap(int i, int j, T[] a) { T t = a[i]; een[i] = een[j]; a[j] = t; } }> |
>
Java-datum naar tekenreeks
>Uitvoer
Sorted Integer array : 6, 22, 41, 50, 58, 100, Sorted Character array : a, c, d, g, t, v, x, Sorted String array : Abhinay, Bharat, Chandu, Kalam, Rohit, Sam, Virat,>
Hier hebben we een generieke methode gemaakt. Dezelfde methode kan worden gebruikt om bewerkingen uit te voeren op gehele gegevens, stringgegevens, enzovoort.
5. Generieke algoritmen implementeren: Door generieke technieken te gebruiken, kunnen we algoritmen implementeren die op verschillende soorten objecten werken, en tegelijkertijd ook typeveilig zijn.