TechCodeview

Le Génériques Java la programmation est introduite dans J2SE 5 pour gérer les objets de type sécurisé. Cela rend le code stable en détectant les bugs au moment de la compilation.

annotations dans Spring Boot

Avant les génériques, nous pouvons stocker n'importe quel type d'objets dans la collection, c'est-à-dire non génériques. Désormais, les génériques obligent le programmeur Java à stocker un type spécifique d'objets.

Avantage des génériques Java

Il y a principalement 3 avantages aux génériques. Ils sont les suivants :

1) Type de sécurité : Nous ne pouvons contenir qu'un seul type d'objets dans les génériques. Il ne permet pas de stocker d'autres objets.

Sans génériques, nous pouvons stocker tout type d'objets.

 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) Le casting de type n’est pas requis : Il n'est pas nécessaire de transtyper l'objet.

Avant Generics, nous devons taper 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) Vérification au moment de la compilation : Il est vérifié au moment de la compilation afin qu'aucun problème ne se produise au moment de l'exécution. La bonne stratégie de programmation dit qu'il est bien préférable de gérer le problème au moment de la compilation plutôt qu'au moment de l'exécution.

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

Syntaxe utiliser une collection générique

 ClassOrInterface 

Exemple utiliser les génériques en Java

 ArrayList 

Exemple complet de génériques en Java

Ici, nous utilisons la classe ArrayList, mais vous pouvez utiliser n'importe quelle classe de collection telle que ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator, etc.

éducation shloka mehta

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

Sortir:

 element is: jai rahul jai 

Exemple de génériques Java utilisant Map

Nous allons maintenant utiliser des éléments cartographiques en utilisant des génériques. Ici, nous devons transmettre la clé et la valeur. Comprenons-le par un exemple simple :

 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>

Sortir

 1 vijay 2 ankit 4 umesh 

Classe générique

Une classe qui peut faire référence à n’importe quel type est appelée classe générique. Ici, nous utilisons le paramètre de type T pour créer la classe générique d'un type spécifique.

Voyons un exemple simple pour créer et utiliser la classe générique.

Création d'une classe générique :

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

Le type T indique qu'il peut faire référence à n'importe quel type (comme String, Integer et Employee). Le type que vous spécifiez pour la classe sera utilisé pour stocker et récupérer les données.

Utilisation d'une classe générique :

Voyons le code pour utiliser la classe générique.

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

Sortir

 2 

Paramètres de type

Les conventions de dénomination des paramètres de type sont importantes pour apprendre à fond les génériques. Les paramètres de type courants sont les suivants :

java main

1. Type T
2. E - Élément
3. K-clé
4. N - Numéro
5. V - Valeur

Méthode générique

Comme la classe générique, nous pouvons créer une méthode générique pouvant accepter tout type d’arguments. Ici, la portée des arguments est limitée à la méthode dans laquelle ils sont déclarés. Il permet des méthodes statiques et non statiques.

Voyons un exemple simple de méthode générique Java pour imprimer des éléments de tableau. Nous utilisons ici ET pour désigner l'élément.

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

Sortir

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

Caractère générique dans les génériques Java

Le ? Le symbole (point d'interrogation) représente l'élément générique. Cela signifie n’importe quel type. Si nous écrivons , cela signifie toute classe enfant de Number, par exemple Integer, Float et double. Nous pouvons maintenant appeler la méthode de la classe Number via n’importe quel objet de classe enfant.

Nous pouvons utiliser un caractère générique comme type d'un paramètre, d'un champ, d'un type de retour ou d'une variable locale. Cependant, il n'est pas autorisé d'utiliser un caractère générique comme argument de type pour un appel de méthode générique, une création d'instance de classe générique ou un supertype. .

Comprenons-le par l'exemple donné ci-dessous :

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

Sortir

 drawing rectangle drawing circle drawing circle 

Caractères génériques à limite supérieure

Le but des caractères génériques de limite supérieure est de réduire les restrictions sur une variable. Il restreint le type inconnu à un type spécifique ou à un sous-type de ce type. Il est utilisé en déclarant le caractère générique ('?') suivi du mot-clé extends (dans le cas de, class) ou Implements (dans le cas de, interface), suivi de sa limite supérieure.

Syntaxe

 List 

Ici,

while boucle java

? est un caractère générique.

s'étend , est un mot-clé.

Nombre , est une classe présente dans le package java.lang

Supposons que nous voulions écrire la méthode pour la liste des nombres et ses sous-types (comme Integer, Double). En utilisant Liste convient à une liste de type Number ou à l'une de ses sous-classes alors que Liste fonctionne avec la liste de type Numéro uniquement. Donc, Liste est moins restrictif que Liste .

Exemple de caractère générique de limite supérieure

Dans cet exemple, nous utilisons les caractères génériques de limite supérieure pour écrire la méthode pour List et List.

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

Sortir

 displaying the sum= 30.0 displaying the sum= 70.0 

Caractères génériques illimités

Le type générique illimité représente la liste d'un type inconnu tel que List. Cette approche peut être utile dans les scénarios suivants : -

• Lorsque la méthode donnée est implémentée à l’aide de la fonctionnalité fournie dans la classe Object.
• Lorsque la classe générique contient les méthodes qui ne dépendent pas du paramètre type.

Exemple de caractères génériques illimités

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

Sortir

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

Caractères génériques à limite inférieure

Le but des caractères génériques de limite inférieure est de restreindre le type inconnu à un type spécifique ou à un supertype de ce type. Il est utilisé en déclarant le caractère générique ('?') suivi du super mot-clé, suivi de sa limite inférieure.

Syntaxe

 List 

Ici,

? est un caractère générique.

super , est un mot-clé.

Entier , est une classe wrapper.

exemple de carte Java

Supposons que nous voulions écrire la méthode pour la liste d'entiers et son supertype (comme Number, Object). En utilisant Liste convient à une liste de type Integer ou à l'une de ses superclasses alors que Liste fonctionne uniquement avec la liste de type Integer. Donc, Liste est moins restrictif que Liste .

Exemple de caractère générique de limite inférieure

Dans cet exemple, nous utilisons les caractères génériques de limite inférieure pour écrire la méthode pour List et List.

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

Sortir

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