De principes van klasseovername onderzoeken
Overname is een van de belangrijkste kenmerken van objectgeoriënteerd programmeren. Hiermee kunt u een hiërarchie van klassen maken door relaties tussen klassen te definiëren. In C# kunt u een basisklasse maken die gemeenschappelijk gedrag en kenmerken definieert en vervolgens afgeleide klassen maakt die dat gedrag overnemen en uitbreiden.
Een basisklasse met de naam Person kan bijvoorbeeld Name en Age eigenschappen definiëren. Een afgeleide klasse met de naam Employee kan deze eigenschappen overnemen en andere eigenschappen zoals EmployeeNumber en Salarydefiniëren.
Dit voorbeeld kan worden weergegeven met behulp van de volgende C#-code:
public class Person
{
public string? Name { get; set; }
public int Age { get; set; }
}
public class Employee : Person
{
public int EmployeeNumber { get; set; }
public decimal Salary { get; set; }
}
Dit codevoorbeeld definieert de Person klasse en vervolgens de Employee klasse. Let op het dubbele punt (:) in de Employee klassedeclaratie. De dubbele punt (:) tussen Employee en Person geeft aan dat de Employee klasse wordt overgenomen van de Person-klasse. In dit geval neemt de Employee klasse de eigenschappen Name en Age over en definieert u nog twee eigenschappen: EmployeeNumber en Salary. Wanneer een Employee object wordt gemaakt, heeft het toegang tot de eigenschappen Name en Age die zijn gedefinieerd in de klasse Person, evenals de eigenschappen EmployeeNumber en Salary die zijn gedefinieerd in de Employee-klasse. Wanneer een Person-object wordt gemaakt, heeft het alleen toegang tot de Name en Age eigenschappen.
Met overname kunt u een hiërarchie van klassen maken die gemeenschappelijk gedrag en kenmerken delen. Hiermee kunt u code hergebruiken en relaties tussen klassen definiëren. Door overname te gebruiken, kunt u beter onderhoudbare en uitbreidbare code maken.
Voordelen van overname
Overname biedt verschillende voordelen, waaronder:
- Code hergebruiken: Overname stelt u in staat om code die is gedefinieerd in een basisklasse in een afgeleide klasse opnieuw te gebruiken. Dit vermindert duplicatie en bevordert het hergebruik van code.
- Uitbreidbaarheid: Met overname kunt u het gedrag van een basisklasse uitbreiden door nieuwe leden toe te voegen aan een afgeleide klasse. U kunt nieuwe eigenschappen, methoden en gebeurtenissen definiëren in een afgeleide klasse.
- Encapsulation: Overname bevordert inkapseling doordat u de implementatiedetails van een basisklasse van een afgeleide klasse kunt verbergen. Met overname en inkapseling kunt u een duidelijke interface definiëren voor interactie met objecten van een afgeleide klasse.
- Consistentie: Overname bevordert consistentie doordat u gemeenschappelijk gedrag in een basisklasse kunt definiëren. Het overnemen van een basisklasse zorgt ervoor dat de afgeleide klassen hetzelfde basisgedrag delen.
- Polymorfisme: Overname maakt polymorfisme mogelijk, waarmee u objecten van een afgeleide klasse kunt behandelen als objecten van hun basisklasse. Met polymorfisme kunt u code schrijven die werkt met objecten van verschillende typen zonder dat u hun specifieke type tijdens het compileren kent.
Klassenovername vergelijken met interface-implementatie
C# biedt twee mechanismen voor het definiëren van relaties tussen klassen: overname van klassen en interface-implementatie. Met klasseovername kan een klasse leden overnemen van een basisklasse, terwijl interface-implementatie een klasse toestaat om leden te implementeren die zijn gedefinieerd in een interface. Beide mechanismen maken het hergebruik van code mogelijk en bevorderen polymorfisme, maar ze hebben verschillende kenmerken:
De overname van klassen heeft de volgende kenmerken:
- Een klasse kan slechts één basisklasse overnemen.
- Een afgeleide klasse kan het gedrag dat in de basisklasse is gedefinieerd, opnieuw gebruiken, uitbreiden en wijzigen.
- Overname maakt een 'is-a'-relatie tussen klassen.
Interface-implementatie heeft de volgende kenmerken:
- Een klasse kan meerdere interfaces implementeren.
- Een klasse kan zijn eigen gedrag definiëren en de leden implementeren die in een interface zijn gedefinieerd.
- Interface-implementatie maakt een 'can-do'-relatie tussen klassen.
Het verschil tussen 'is-a' en 'can-do'-relaties is belangrijk bij het ontwerpen van objectgeoriënteerde systemen. Over het algemeen moet u klasseovername gebruiken wanneer een afgeleide klasse een gespecialiseerde versie van een basisklasse is. U moet interface-implementatie gebruiken wanneer een klasse een specifieke set acties kan uitvoeren.
Een voorbeeld van wanneer u klasseovername moet gebruiken, is wanneer u een basisklasse hebt met de naam Dog en afgeleide klassen met de naam German Shepherd en Golden Retriever. De German Shepherd en Golden Retriever zijn gespecialiseerde versies van een Dog. In dit geval kunt u de overname van klassen gebruiken om een gemeenschappelijke set eigenschappen en methoden in de Dog klasse te definiëren en dit gedrag vervolgens uit te breiden en te wijzigen in de klassen German Shepherd en Golden Retriever.
Een voorbeeld van wanneer u interface-implementatie moet gebruiken, is wanneer u een interface hebt met de naam IDrawable waarmee een Draw methode wordt gedefinieerd. U kunt de IDrawable interface implementeren in klassen die kunnen worden getekend, zoals Circle en Rectangle. In dit geval kunt u interface-implementatie gebruiken om een gemeenschappelijke set acties te definiëren die worden gedeeld door verschillende klassen.
Klassenovername vergelijken met polymorfisme
Klassenovername en polymorfisme zijn nauw verwante concepten in objectgeoriënteerde programmering. Met overname kunt u een hiërarchie definiëren van klassen die gemeenschappelijk gedrag delen, terwijl polymorfisme u toestaat om objecten van een afgeleide klasse te behandelen als objecten van hun basisklasse.
Denk bijvoorbeeld aan een basisklasse met de naam HousePet en afgeleide klassen met de naam Dog en Cat. De klasse HousePet definieert een Speak methode die een tekenreeks retourneert die het geluid vertegenwoordigt dat het huisdier maakt. De Dog klasse overschrijft de Speak methode om Woof te retourneren en de Cat klasse overschrijft de Speak methode om 'Meow' te retourneren. U kunt een HousePet object maken met de naam myPet van het type Dog of Cat en de Speak methode aanroepen om het juiste antwoord te krijgen.
In dit voorbeeld definieert de HousePet-klasse een gemeenschappelijk Speak gedrag dat de Dog en Cat klassen delen. De klassen Dog en Cat overschrijven de methode Speak om het gedrag aan te passen. Wanneer u de methode Speak aanroept op een HousePet-object dat verwijst naar een van de afgeleide klassen, krijgt u het juiste antwoord op basis van het type object. Hier volgt het codevoorbeeld dat dit concept laat zien:
HousePet myPet1 = new Dog(); // Create a HousePet object named myPet1 that's of type Dog
HousePet myPet2 = new Cat(); // Create a HousePet object named myPet2 that's of type Cat
Console.WriteLine(myPet1.Speak()); // Call the Speak method on myPet1
Console.WriteLine(myPet2.Speak()); // Call the Speak method on myPet2
// Output: Woof
// Meow
public class HousePet
{
public virtual string Speak()
{
return "Hello";
}
}
public class Dog : HousePet
{
public override string Speak()
{
return "Woof";
}
}
public class Cat : HousePet
{
public override string Speak()
{
return "Meow";
}
}
Met polymorfisme kunt u code schrijven die werkt met objecten van verschillende typen zonder dat u het specifieke type op het moment van compileren kent. In dit voorbeeld wordt polymorfisme bereikt door exemplaren van de HousePet-klasse te maken die van het type Dog of Catzijn. De methode Speak wordt aangeroepen op de HousePet objecten en het juiste antwoord wordt geretourneerd op basis van het type object, 'Woof' of 'Meow'. In C# kan polymorfisme worden bereikt met behulp van klasseovername of interface-implementatie.
Samenvatting
Overname is een fundamenteel concept in objectgeoriënteerde programmering waarmee u een hiërarchie van klassen kunt maken door relaties tussen klassen te definiëren. In C# kunt u de overname van klassen gebruiken om een basisklasse te maken die gemeenschappelijk gedrag en kenmerken definieert en vervolgens afgeleide klassen maakt die dat gedrag overnemen en uitbreiden. Overname biedt verschillende voordelen, waaronder hergebruik van code, uitbreidbaarheid, inkapseling, consistentie en polymorfisme. Door overname te gebruiken, kunt u beter onderhoudbare en uitbreidbare code maken.