Wat is abstracte klasse in C #?
Het woord abstract betekent een gedachte of een idee dat geen fysieke vorm van zichzelf heeft, maar fungeert als basis voor andere dingen. Hetzelfde is het concept achter abstracte klasse. In dit artikel bespreken we abstracte klassen in C #. Een abstracte klasse is een speciale klasse in C # die niet kan worden geïnstantieerd, dat wil zeggen dat u geen objecten van een abstracte klasse kunt maken. Het doel van een abstracte klasse is om een skeletstructuur te bieden voor andere klassen om van af te leiden. Abstracte klassen hebben geen eigen implementatie. Ze vereisen dat de ontwikkelaars en programmeurs voortkomen uit de abstracte klasse en voortbouwen op de skeletstructuur, dwz hun implementatie schrijven. Een abstracte klasse kan ook abstracte methodeverklaringen bevatten. Nogmaals, deze methoden kunnen geen definities bevatten.
De syntaxis van het verklaren van abstracte klassen en methoden houdt in dat het trefwoord abstract vóór de aangifte wordt geplaatst. Zo simpel is het.
Syntaxis:
abstract class ClassName
(
public abstract void MethodName();
)
Vergeet niet dat abstracte methoden geen definities kunnen hebben. De declaraties van de abstracte methode eindigen dus met een puntkomma. Ze kunnen alleen worden aangegeven. De definities moeten worden verstrekt in afgeleide niet-abstracte klassen.
Hoe werkt Abstract Class in C #?
Het abstracte trefwoord instrueert de compiler dat de klasse een skeletstructuur van de basisklasse is die in afgeleide klassen moet worden geïmplementeerd. Als de compiler een klasse vindt die de abstracte basisklasse afleidt, controleert deze of alle abstracte methoden en eigenschappen worden overschreven en geïmplementeerd in de afgeleide klasse.
Abstracte klasse versus interface
Nu vraag je je misschien af wat dit allemaal is en wat de interface doet. Dus, hoe verschilt een abstracte klasse van een interface?
Laten we dit met een voorbeeld begrijpen. Laten we zeggen dat we een uitgeverij runnen en een paar editors hebben ingehuurd om columns voor ons magazine te schrijven. Laten we aannemen dat ze experts in verschillende genres zijn, artikelen schrijven die op een specifieke dag van de week worden gepubliceerd en allemaal met hetzelfde salaris worden aangenomen.
Laten we de abstracte werknemersklasse voor onze editors definiëren.
Code:
abstract class EmployeeEditors
(
public abstract void Genre();
public abstract string PublishDay();
public int Payment()
(
Console.Write(“Monthly salary is (0)$.”, 1000);
)
)
We kunnen de betaalmethode eenvoudig implementeren, wetende dat deze voor iedereen hetzelfde zou zijn. De andere twee methoden werden abstract verklaard om te worden geïmplementeerd door de afgeleide klasse. Men zou een normale klasse voor elke editor kunnen verklaren die is afgeleid van de abstracte klasse en vervolgens de abstracte methoden kunnen implementeren om de genres en dagen te definiëren. Veronderstel nu dat het salaris van elke editor ook anders is. Een manier om onze code te wijzigen is om de betaalmethode abstract te verklaren. De andere manier zou zijn om de hele EmployeeEditor als een interface te verklaren en volledige vrijheid te geven aan het erven van klassen.
Public interface EmployeeEditors
(
public abstract void Genre();
public abstract string PublishDay();
public abstract int Payment();
)
Een abstracte klasse is dus een basisklasse waarop andere klassen kunnen voortbouwen. Terwijl een interface een blauwdruk is voor andere klassen om naar te verwijzen en vanaf nul te bouwen.
Regels van abstracte klasse in C #
Er zijn bepaalde regels die moeten worden gevolgd bij het werken met abstracte klassen.
- Omdat abstracte klassen onvolledige methodedefinities hebben, kunnen ze niet worden geïnstantieerd. Elke poging om een object van een abstracte klasse te maken, zou een compilatie-fout veroorzaken.
- Abstracte methoden kunnen niet worden gedefinieerd in abstracte klassen, maar alleen worden verklaard. De methode body moet worden gedefinieerd in afgeleide klassen.
- Afgeleide klassen moeten alle abstracte methoden implementeren.
- Abstracte methoden kunnen niet statisch of virtueel zijn.
Voorbeeld van abstracte klasse in C #
Probleemstelling: Laten we nog een voorbeeld uit de echte wereld nemen. Stel dat u wordt gevraagd het proces van het genereren van aanbiedingsbrieven voor een bepaalde organisatie te automatiseren. Het huidige proces is volledig handmatig en vereist het bewerken van bestaande aanbiedingsbrieven, wat foutgevoelig is. Er zijn bepaalde dingen die gebruikelijk zijn voor alle aanbiedingsbrieven, zoals werklocatie, werktijden, bedrijfsnaam, bedrijfslogo, enz. Andere zaken zoals naam van de werknemer, functie, salaris, datum van toetreding, enz. Zijn specifiek voor elke aanbieding brief.
Oplossing : U zou een abstracte klasse ontwerpen voor het bovenstaande doel. Laten we eens kijken hoe.
Code:
ode: using System;
abstract class OfferLetter
(
public abstract string Name(string name);
public abstract string Designation(string designation);
public abstract int Payment(int pay);
public abstract string DOJ(string doj);
public string CompanyName()
(
return "XYZ Corporation Pvt. Ltd.";
)
public string OfficeAddress()
(
return "512, Manhattan, NY";
)
public string CompanyBranding()
(
return this.CompanyName() + " is a privately owned regsitered corporation operating \n under the license provided by the state of New York.";
)
public string Disclaimer()
(
return "This letter and its contents are confidential in nature and are intended only \n for the recipient."+
"\nIf you are not the correct recipient, kindly return it immediately \n to " + this.CompanyName() + " " + this.OfficeAddress() + ".";
)
)
class PrintOfferLetter : OfferLetter
(
public override string Name(string name)
(
return name;
)
public override string Designation(string designation)
(
return designation;
)
public override int Payment(int pay)
(
return pay;
)
public override string DOJ(string doj)
(
return doj;
)
)
public class Program
(
public static void Main()
(
PrintOfferLetter ltr = new PrintOfferLetter();
string empName = "Mr. ABC", designation = "Senior Consultant", doj = "20-02-2020";
int pay = 50000;
Console.WriteLine(ltr.CompanyName() + " is very happy to extend this offer letter to \n" + ltr.Name(empName)
+ " at the designation of " + ltr.Designation(designation) + " with an annual pay of " + ltr.Payment(pay) + "$.");
Console.WriteLine("\nYou are required to report at " + ltr.OfficeAddress() + " from " + ltr.DOJ(doj) + " (dd-mm-yyyy).");
Console.WriteLine("\n\n" + ltr.CompanyBranding());
Console.WriteLine("\n\n" + ltr.Disclaimer());
)
)
Output:
Conclusie
Kortom, een abstracte klasse is gewoon een onvolledige of gedeeltelijk complete klasse die andere klassen kunnen afleiden en er hun logica bovenop kunnen bouwen. In dit artikel hebben we gezien hoe een abstracte klasse wordt verklaard en werkt. We zagen voorbeelden uit de praktijk van het gebruik van abstracte klassen en hoe deze verschillen van interfaces. Het wordt aanbevolen om zoveel mogelijk abstracte klassen in uw code te gebruiken. Dit is een cruciale praktijk van goed programmeren.
Aanbevolen artikelen
Dit is een gids voor Abstract Class in C #. Hier bespreken we de definitie en hoe abstract klasse werkt in C # samen met regels en een voorbeeld. U kunt ook onze andere gerelateerde artikelen doornemen voor meer informatie -
- Wat zijn abstracte klassen in JavaScript?
- Abstracte klasse in C ++? (Voorbeelden)
- Wat is abstracte klasse in PHP?
- Overzicht van abstracte klasse in Python