Comment créer et utiliser une classe générique en Java

Les génériques sont un concept de programmation qui vous permet de spécifier le type que vous avez l'intention de stocker dans une collection. Un type générique peut être n'importe quelle valeur non primitive. Les paramètres de type traditionnels que vous connaissez peut-être sont la chaîne et l'entier.

Cependant, vous pouvez créer un type générique unique. De plus, vous pouvez créer une classe générique et l'utiliser pour créer différentes collections à l'aide de génériques.

Création d'un type générique

Un type générique est essentiellement un objet, créé à l'aide d'une classe ou une interface. Ainsi, pour cet article, le type générique sera un client. À l'aide d'un exemple d'application au niveau de l'entreprise, le client représente une entité dans un système de base de données. Ce système de base de données dessert une entreprise de meubles qui possède trois emplacements physiques dans trois villes différentes.

publicabstractclassCustomer{
private String name;
publicCustomer(String name){
this.name = name;
 }
public String getName(){
return name;
 }
}

Vous remarquerez la abstrait mot-clé dans le Client déclaration de classe ci-dessus. Cela signifie que vous ne pouvez pas créer un type direct ou un objet à partir du Client taper.

Étant donné que chaque emplacement de magasin physique aura une liste unique de clients, l'application devra avoir trois sous-classes de clients que vous implémenterez à l'aide de le concept de programmation d'héritage.

Ces trois sous-classes seront les types solides au générique Client taper. La première Client la sous-classe contiendra le code suivant :

publicclassCity1CustomerextendsCustomer{
publicCity1Customer(String name){
super(name);
 }
}

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

Pour utiliser un type générique, vous devez disposer d'une classe ou d'une méthode générique qui accepte ce type en tant que paramètre. Pour créer une classe générique, il suffit d'insérer le paramètre type dans la déclaration de classe.

publicclassPromotion<T> {}

Le code ci-dessus indique que le Promotion la classe est générique. Cela signifie que le Promotion La classe utilise des types pour créer ses objets. Désormais, la déclaration de classe peut prendre une collection d'objets qui sont des chaînes, des entiers, des clients, etc. Cependant, l'entreprise de meubles ne veut que le Promotion classe pour créer des objets à l'aide de la Client les types.

publicclassPromotion<TextendsCustomer> {}

Le code mis à jour ci-dessus garantit que le Promotion la classe ne prend que Client types, cela signifie toutes les sous-classes du Client classe.

Étant donné qu'il y a trois magasins, l'entreprise souhaite créer une promotion indépendante pour chaque magasin. Les données requises pour ces promotions sont similaires. Chaque promotion aura un nom et une collection de clients qui ont gagné dans cette promotion.

Il existe plusieurs façons d'aborder ce problème. Vous pourriez créer un Promotion classe parente et ont trois sous-classes pour chaque emplacement de magasin. Mais puisque chacun Promotion a une structure similaire, vous finirez par écrire du code en double, ce qui est inefficace (d'autant plus que vous travaillez déjà avec Client sous-classes).

Par conséquent, un Promotion La classe générique est l'une des solutions les plus efficaces à ce problème.

import java.util.ArrayList;
publicclassPromotion<TextendsCustomer> {
private String promoName; 
private ArrayList winners = new ArrayList<>();
publicPromotion(String promoName){
this.promoName = promoName;
 }
public String getPromoName(){
return promoName;
 }
publicvoidaddCustomer(T customer){
if (winners.contains(customer)) {
 System.out.println( customer.getName() + " is already a winner of this prize."); 
 } else {
 winners.add(customer);
 System.out.println( customer.getName() + " is a winner in the " + this.promoName);
 }
 }
publicintnumWinners(){
returnthis.winners.size();
 } 
}

Le Promotion classe générique a une seule variable (nom de la promotion). Cette classe Java accepte une collection de clients qui ont remporté la promotion (gagnants) et les stocke dans un Structure de données ArrayList. Pour ajouter un nouveau client à une collection de promotions spécifique, vous devez utiliser le ajouterClient() méthode. Si, à tout moment, vous souhaitez connaître le nombre de clients qui se trouvent dans une collection, vous pouvez invoquer le nombre de gagnants() méthode.

Création de collections à l'aide d'une classe générique

Avant de pouvoir commencer à créer des collections, vous devez créer des clients.

publicclassMain{
publicstaticvoidmain(String[] args){
 City1Customer john = new City1Customer("John Brown");
 City1Customer kelly = new City1Customer("Kelly James");
 City2Customer jane = new City2Customer("Jane Doe");
 City3Customer jess = new City3Customer("Jess Smith");
 }
}

Le Principal La classe ci-dessus crée quatre objets client, chacun appartenant à l'un des trois emplacements de magasin. Pour commencer à créer des collections, vous devrez d'abord créer des objets de promotion (un pour chaque emplacement de magasin).

Promotion city1promo = new Promotion("City1 Promo");
Promotion city2promo = new Promotion("City2 Promo");
Promotion city3promo = new Promotion("City3 Promo");

En insérant les trois lignes de code ci-dessus dans le Principal classe créera effectivement trois promotions spécifiques au type (ou à l'emplacement). Ainsi, seuls les clients du magasin du premier emplacement de la ville (City1Customer) peut gagner la promotion de cette ville (city1promo).

city1promo.addCustomer(john);
city1promo.addCustomer(kelly);

Par conséquent, en ajoutant le code ci-dessus au Principal class produira le résultat suivant dans la console :

Cependant, si vous essayez d'ajouter un troisième client à la liste des gagnants de la promotion dans la première ville, votre IDE produirait une erreur de compilation.

C'est parce que ni Jeanne ni Jesse est client du magasin de la première ville. La création de types et de classes génériques est utile, car elle empêche ces erreurs simples de ne pas être détectées et de corrompre la base de données d'un système. Dans une petite application, il peut être facile de repérer des erreurs comme celle-ci, mais dans un système au niveau de l'entreprise, des erreurs comme celle-ci peuvent ne pas être détectées.

city2promo.addCustomer(jane);

Remplacer la ligne de code erronée par celle ci-dessus imprimera la sortie suivante sur la console :

Avantages de l'utilisation des types génériques

À partir de l'exemple d'application de cet article, vous pouvez voir qu'un avantage majeur de l'utilisation de types génériques est la vérification de type au moment de la compilation. Sans vérification de type, l'ajout de Jane à l'une des trois listes de promotions ne produirait pas d'erreur de temps d'exécution, car Jane est en effet un client de l'entreprise de meubles.

Les génériques offrent également plusieurs autres avantages, notamment la réutilisation et l'évolutivité du code. Au fur et à mesure que l'entreprise s'étend à de nouvelles villes, vous pouvez facilement créer de nouveaux types d'objets de promotion, en vous appuyant fortement sur le code existant. Les types génériques vous permettent également de créer un code efficace, ce qui est une priorité absolue dans le processus de développement logiciel.