Hoe een generieke klasse in Java te maken en te gebruiken

Generics is een programmeerconcept waarmee u het type kunt specificeren dat u in een verzameling wilt opslaan. Een generiek type kan elke niet-primitieve waarde zijn. De traditionele parameters van het type waarmee u wellicht bekend bent, zijn string en integer.

U kunt echter een uniek generiek type maken. Bovendien kunt u een generieke klasse maken en deze gebruiken om verschillende collecties te maken met behulp van generieke klassen.

Een generiek type maken

Een generiek type is in wezen een object, gemaakt met behulp van een klasse of een interface. Dus voor dit artikel is het generieke type een klant. Met behulp van een voorbeeldtoepassing op bedrijfsniveau vertegenwoordigt de klant een entiteit in een databasesysteem. Dit databasesysteem bedient een meubelbedrijf met drie fysieke locaties in drie verschillende steden.

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

U zult de abstract trefwoord in de Klant klassendeclaratie hierboven. Dit betekent dat u geen direct type of object kunt maken van het Klant type.

Aangezien elke fysieke winkellocatie een unieke lijst met klanten heeft, moet de toepassing drie klantsubklassen hebben die u gaat implementeren met behulp van het concept van erfenisprogrammering.

Deze drie subklassen zijn de solide typen voor de generieke Klant type. De eerste Klant subklasse zal de volgende code bevatten:

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

Een generieke klasse maken

Om een ​​generiek type te gebruiken, moet u een generieke klasse of methode hebben die dit type als parameter accepteert. Om een ​​generieke klasse te maken, hoeft u alleen maar de parameter type in de klassendeclaratie in te voegen.

publicclassPromotion<T> {}

Bovenstaande code geeft aan dat de Promotie klasse is generiek. Dit betekent dat de Promotie klasse gebruikt typen om zijn objecten te maken. Nu kan de klassendeclaratie een verzameling objecten aannemen die strings, gehele getallen, klanten, enzovoort zijn. Het meubelbedrijf wil echter alleen de Promotie class om objecten te maken met behulp van de Klant soorten.

publicclassPromotion<TextendsCustomer> {}

De bijgewerkte code hierboven zorgt ervoor dat de Promotie klasse neemt alleen de Klant typen, dit betekent alle subklassen van de Klant klas.

Aangezien er drie winkels zijn, wil het bedrijf voor elke winkel één onafhankelijke promotie maken. De gegevens die nodig zijn voor deze promoties zijn vergelijkbaar. Elke promotie heeft een naam en een verzameling klanten die in die promotie hebben gewonnen.

Er zijn verschillende manieren om dit probleem te benaderen. Je zou een Promotie bovenliggende klasse en hebben drie subklassen voor elke winkellocatie. Maar aangezien elk Promotie een vergelijkbare structuur heeft, zul je uiteindelijk dubbele code schrijven, wat inefficiënt is (vooral omdat je al werkt met Klant subklassen).

Daarom een Promotie generieke klasse is een van de efficiëntere oplossingen voor dit probleem.

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

De Promotie generieke klasse heeft een enkele variabele (promoNaam). Deze Java-klasse accepteert een verzameling klanten die de actie hebben gewonnen (winnaars) en slaat deze op in een ArrayList-gegevensstructuur. Om een ​​nieuwe klant aan een specifieke promotiecollectie toe te voegen, moet u de addKlant() methode. Als u op enig moment het aantal klanten in een collectie wilt weten, kunt u een beroep doen op de aantalWinnaars() methode.

Collecties maken met behulp van een generieke klasse

Voordat u kunt beginnen met het maken van collecties, moet u klanten maken.

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

De Voornaamst class hierboven maakt vier klantobjecten, elk behorend bij een van de drie winkellocaties. Om te beginnen met het maken van collecties, moet u eerst promotie-objecten maken (één voor elke winkellocatie).

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

Het invoegen van de drie regels code hierboven in het Voornaamst class zal in feite drie typespecifieke (of locatiespecifieke) promoties maken. Dus alleen klanten van de winkel in de eerste stadslocatie (Stad1Klant) kan een winnaar zijn in de promotie van die stad (stad1promo).

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

Voeg daarom de bovenstaande code toe aan het Voornaamst class produceert het volgende resultaat in de console:

Als u echter een derde klant probeert toe te voegen aan de lijst met promotiewinnaars in de eerste stad, geeft uw IDE een compilatiefout.

Dit komt omdat geen van beide Jane noch Jess is een klant van de winkel in de eerste stad. Het maken van generieke typen en klassen is handig, omdat het voorkomt dat deze eenvoudige fouten onopgemerkt blijven en de database van een systeem beschadigen. In een kleine applicatie kan het gemakkelijk zijn om dergelijke fouten te ontdekken, maar in een systeem op bedrijfsniveau kunnen dergelijke fouten onopgemerkt blijven.

city2promo.addCustomer(jane);

Als u de foutieve coderegel vervangt door die hierboven, wordt de volgende uitvoer naar de console afgedrukt:

Voordelen van het gebruik van de generieke typen

Uit de voorbeeldtoepassing in dit artikel kunt u zien dat een groot voordeel van het gebruik van generieke typen typecontrole tijdens het compileren is. Zonder typecontrole zou het toevoegen van Jane aan een van de drie promotielijsten geen uitvoeringstijdfout opleveren, aangezien Jane inderdaad een klant is van het meubelbedrijf.

Generics biedt ook verschillende andere voordelen, waaronder herbruikbaarheid van code en schaalbaarheid. Naarmate het bedrijf uitbreidt naar nieuwe steden, kunt u eenvoudig nieuwe typen promotieobjecten maken, waarbij u sterk leunt op de bestaande code. Met generieke typen kunt u ook efficiënte code maken, wat een topprioriteit is in het softwareontwikkelingsproces.