Come creare e utilizzare una classe generica in Java

Generics è un concetto di programmazione che consente di specificare il tipo che si intende archiviare in una raccolta. Un tipo generico può essere qualsiasi valore non primitivo. I parametri di tipo tradizionali con cui potresti avere familiarità sono string e integer.

È tuttavia possibile creare un tipo generico univoco. Inoltre, puoi creare una classe generica e utilizzarla per creare raccolte diverse utilizzando i generici.

Creazione di un tipo generico

Un tipo generico è essenzialmente un oggetto, creato utilizzando una classe o un'interfaccia. Quindi, per questo articolo, il tipo generico sarà un cliente. Utilizzando un'applicazione di livello aziendale di esempio, il cliente rappresenta un'entità in un sistema di database. Questo sistema di database serve un'azienda di mobili che ha tre sedi fisiche in tre diverse città.

publicabstractclassCustomer{
private





instagram viewer
 String name;
publicCustomer(String name){
this.name = name;
 }
public String getName(){
return name;
 }
}

Noterai il astratto parola chiave in Cliente dichiarazione di classe sopra. Significa che non è possibile creare un tipo o un oggetto diretto dal file Cliente tipo.

Dato che ogni punto vendita fisico avrà un elenco univoco di clienti, l'applicazione dovrà disporre di tre sottoclassi di clienti che implementerai utilizzando il concetto di programmazione ereditaria.

Queste tre sottoclassi saranno i tipi solidi rispetto al generico Cliente tipo. Il primo Cliente sottoclasse conterrà il seguente codice:

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

Creazione di una classe generica

Per utilizzare un tipo generico, è necessario disporre di una classe o di un metodo generico che accetti questo tipo come parametro. Per creare una classe generica è sufficiente inserire il parametro type nella dichiarazione della classe.

publicclassPromotion<T> {}

Il codice sopra indica che il Promozione la classe è generica. Ciò significa che il Promozione la classe usa i tipi per creare i suoi oggetti. Ora la dichiarazione di classe può accettare una raccolta di oggetti che sono stringhe, numeri interi, clienti e così via. Tuttavia, l'azienda di mobili vuole solo il Promozione class per creare oggetti utilizzando il Cliente tipi.

publicclassPromotion<TextendsCustomer> {}

Il codice aggiornato sopra garantisce che il file Promozione classe prende solo il Cliente tipi, questo significa tutte le sottoclassi di Cliente classe.

Dato che ci sono tre negozi, l'azienda vuole creare una promozione indipendente per ogni negozio. I dati richiesti per queste promozioni sono simili. Ogni promozione avrà un nome e una raccolta di clienti che hanno vinto in quella promozione.

Ci sono diversi modi per affrontare questo problema. Potresti creare un file Promozione classe genitore e hanno tre sottoclassi per ogni punto vendita. Ma poiché ciascuno Promozione ha una struttura simile, finirai per scrivere codice duplicato, che è inefficiente (soprattutto perché stai già lavorando con Cliente sottoclassi).

Pertanto, A Promozione classe generica è una delle soluzioni più efficienti a questo problema.

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

IL Promozione classe generica ha una singola variabile (nomepromo). Questa classe Java accetta una raccolta di clienti che hanno vinto la promozione (vincitori) e li memorizza in un file Struttura dati ArrayList. Per aggiungere un nuovo cliente a una specifica raccolta di promozioni, devi utilizzare il file aggiungicliente() metodo. Se in qualsiasi momento si desidera conoscere il numero di clienti presenti in una raccolta, è possibile richiamare il file numVincitori() metodo.

Creazione di raccolte utilizzando una classe generica

Prima di poter iniziare a creare collezioni, dovrai creare clienti.

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

IL Principale class sopra crea quattro oggetti cliente, ciascuno appartenente a una delle tre posizioni del negozio. Per iniziare a creare collezioni dovrai prima creare oggetti promozione (uno per ogni punto vendita).

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

Inserendo le tre righe di codice sopra nel file Principale class creerà effettivamente tre promozioni specifiche del tipo (o specifiche della posizione). Quindi, solo i clienti del negozio nella prima sede della città (Città1Cliente) può essere vincente nella promozione di quella città (città1promo).

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

Pertanto, aggiungendo il codice sopra al file Principale class produrrà il seguente risultato nella console:

Tuttavia, se provi ad aggiungere un terzo cliente all'elenco dei vincitori della promozione nella prima città, il tuo IDE genererebbe un errore di compilazione.

Questo perché nessuno dei due Jane né Jesse è un cliente del negozio nella prima città. La creazione di tipi e classi generici è utile, poiché impedisce a questi semplici errori di non essere rilevati e di danneggiare il database di un sistema. In una piccola applicazione, può essere facile individuare errori come questo, ma in un sistema di livello aziendale, errori come questo potrebbero non essere rilevati.

city2promo.addCustomer(jane);

Sostituendo la riga di codice errata con quella sopra verrà stampato il seguente output sulla console:

Vantaggi dell'utilizzo dei tipi generici

Dall'applicazione di esempio in questo articolo è possibile vedere che uno dei principali vantaggi dell'uso di tipi generici è il controllo del tipo in fase di compilazione. Senza il controllo del tipo, l'aggiunta di Jane a uno qualsiasi dei tre elenchi di promozioni non genererebbe un errore in fase di esecuzione, poiché Jane è effettivamente una cliente dell'azienda di mobili.

Generics facilita anche molti altri vantaggi tra cui la riusabilità e la scalabilità del codice. Man mano che l'azienda si espande in nuove città, puoi facilmente creare nuovi tipi di oggetti promozionali, facendo molto affidamento sul codice esistente. I tipi generici consentono inoltre di creare codice efficiente, che è una priorità assoluta nel processo di sviluppo del software.