Der Java-Generika In J2SE 5 wird die Programmierung für den Umgang mit typsicheren Objekten eingeführt. Es macht den Code stabil, indem es die Fehler zur Kompilierungszeit erkennt.

auswählen als

Vor Generika können wir jede Art von Objekten in der Sammlung speichern, also nicht generische. Jetzt zwingen Generika den Java-Programmierer, einen bestimmten Objekttyp zu speichern.

Vorteil von Java Generics

Es gibt hauptsächlich drei Vorteile von Generika. Sie sind wie folgt:

1) Typensicherheit: Wir können nur einen einzigen Objekttyp in Generics speichern. Es ist nicht möglich, andere Objekte zu speichern.

Ohne Generics können wir jede Art von Objekten speichern.

 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) Typguss ist nicht erforderlich: Es ist nicht erforderlich, das Objekt zu typisieren.

Vor Generics müssen wir Cast eingeben.

 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) Überprüfung der Kompilierungszeit: Es wird zur Kompilierzeit überprüft, sodass zur Laufzeit kein Problem auftritt. Die gute Programmierstrategie besagt, dass es weitaus besser ist, das Problem zur Kompilierungszeit als zur Laufzeit zu lösen.

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

Syntax generische Sammlung verwenden

 ClassOrInterface 

Beispiel um Generics in Java zu verwenden

 ArrayList 

Vollständiges Beispiel für Generics in Java

Hier verwenden wir die ArrayList-Klasse, Sie können jedoch jede beliebige Sammlungsklasse wie ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator usw. verwenden.

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

Ausgabe:

 element is: jai rahul jai 

Beispiel für Java Generics mit Map

Jetzt werden wir Kartenelemente mithilfe von Generika verwenden. Hier müssen wir Schlüssel und Wert übergeben. Lassen Sie es uns anhand eines einfachen Beispiels verstehen:

 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>

Ausgabe

 1 vijay 2 ankit 4 umesh 

Generische Klasse

Eine Klasse, die auf einen beliebigen Typ verweisen kann, wird als generische Klasse bezeichnet. Hier verwenden wir den T-Typ-Parameter, um die generische Klasse eines bestimmten Typs zu erstellen.

Sehen wir uns ein einfaches Beispiel zum Erstellen und Verwenden der generischen Klasse an.

Erstellen einer generischen Klasse:

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

Der T-Typ gibt an, dass er auf jeden Typ verweisen kann (z. B. String, Integer und Employee). Der Typ, den Sie für die Klasse angeben, wird zum Speichern und Abrufen der Daten verwendet.

zu einem Array in Java hinzufügen

Verwendung einer generischen Klasse:

Sehen wir uns den Code zur Verwendung der generischen Klasse an.

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

Ausgabe

 2 

Geben Sie Parameter ein

Die Namenskonventionen für Typparameter sind wichtig, um Generika gründlich zu erlernen. Die allgemeinen Typparameter lauten wie folgt:

vlc zum Herunterladen von YouTube

1. T – Typ
2. E – Element
3. K – Schlüssel
4. N – Zahl
5. V – Wert

Generische Methode

Wie die generische Klasse können wir eine generische Methode erstellen, die jede Art von Argumenten akzeptieren kann. Hier ist der Umfang der Argumente auf die Methode beschränkt, in der sie deklariert werden. Es ermöglicht sowohl statische als auch nicht statische Methoden.

Sehen wir uns ein einfaches Beispiel einer generischen Java-Methode zum Drucken von Array-Elementen an. Wir verwenden hier UND um das Element zu bezeichnen.

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

Ausgabe

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

Platzhalter in Java Generics

Der ? Das Symbol (Fragezeichen) stellt das Platzhalterelement dar. Es bedeutet jeden Typ. Wenn wir schreiben, bedeutet dies jede untergeordnete Klasse von Number, z. B. Integer, Float und Double. Jetzt können wir die Methode der Number-Klasse über jedes untergeordnete Klassenobjekt aufrufen.

Wir können einen Platzhalter als verwenden Typ eines Parameters, Felds, Rückgabetyps oder einer lokalen Variablen. Es ist jedoch nicht zulässig, einen Platzhalter als Typargument für einen generischen Methodenaufruf, die Erstellung einer generischen Klasseninstanz oder einen Supertyp zu verwenden .

Lassen Sie es uns anhand des folgenden Beispiels verstehen:

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

Ausgabe

 drawing rectangle drawing circle drawing circle 

Platzhalter mit Obergrenze

Der Zweck von Platzhaltern mit Obergrenze besteht darin, die Einschränkungen für eine Variable zu verringern. Es schränkt den unbekannten Typ auf einen bestimmten Typ oder einen Untertyp dieses Typs ein. Es wird verwendet, indem ein Platzhalterzeichen („?“) deklariert wird, gefolgt vom Schlüsselwort „extends“ (im Fall von „class“) oder „implements“ (im Fall von „interface“), gefolgt von der Obergrenze.

Nick Pulos schwarzer Blitz

Syntax

 List 

Hier,

? ist ein Platzhalterzeichen.

erweitert , ist ein Schlüsselwort.

Nummer ist eine Klasse, die im Paket java.lang vorhanden ist

Angenommen, wir möchten die Methode für die Liste von Number und ihren Untertypen (wie Integer, Double) schreiben. Benutzen Aufführen eignet sich für eine Liste vom Typ Number oder eine seiner Unterklassen, wohingegen Aufführen Funktioniert nur mit der Liste vom Typ Zahl. Also, Aufführen ist weniger restriktiv als Aufführen .

Beispiel für einen Platzhalter für die Obergrenze

In diesem Beispiel verwenden wir die Platzhalter für die Obergrenze, um die Methode für List und List zu schreiben.

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

Ausgabe

 displaying the sum= 30.0 displaying the sum= 70.0 

Unbegrenzte Platzhalter

Der unbegrenzte Platzhaltertyp stellt die Liste eines unbekannten Typs dar, z. B. List. Dieser Ansatz kann in den folgenden Szenarien nützlich sein: -

• Wenn die angegebene Methode mithilfe der in der Object-Klasse bereitgestellten Funktionalität implementiert wird.
• Wenn die generische Klasse die Methoden enthält, die nicht vom Typparameter abhängen.

Beispiel für unbegrenzte Platzhalter

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

Ausgabe

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

Platzhalter mit niedrigerer Grenze

Der Zweck von Platzhaltern mit niedrigerer Grenze besteht darin, den unbekannten Typ auf einen bestimmten Typ oder einen Supertyp dieses Typs einzuschränken. Es wird verwendet, indem ein Platzhalterzeichen ('?') gefolgt vom Schlüsselwort super und seiner Untergrenze deklariert wird.

Syntax

 List 

Hier,

? ist ein Platzhalterzeichen.

super , ist ein Schlüsselwort.

Ganze Zahl ist eine Wrapper-Klasse.

Madhuri sagte, komm schon

Angenommen, wir möchten die Methode für die Liste von Integer und ihren Supertyp (wie Number, Object) schreiben. Benutzen Aufführen ist für eine Liste vom Typ Integer oder eine seiner Oberklassen geeignet Aufführen Funktioniert nur mit der Liste vom Typ Integer. Also, Aufführen ist weniger restriktiv als Aufführen .

Beispiel für einen Platzhalter für die untere Grenze

In diesem Beispiel verwenden wir die unteren Platzhalter, um die Methode für List und List zu schreiben.

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

Ausgabe

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