Inhoudsopgave
- Enkele erfenis
- Overerving op meerdere niveaus
- Hiërarchische erfenis
- Meerdere overerving (niet ondersteund in C#)
Wat is overerving in C#
In C# kan een klasse met overerving de eigenschappen en methoden van een andere klasse overnemen of erven. Met andere woorden, het maakt de creatie van een nieuwe klasse mogelijk op basis van een bestaande klasse, die bekend staat als de basisklasse of superklasse. Een klasse die is gevormd na het nemen van de eigenschappen van een basisklasse, wordt aangeroepen een afgeleide klasse of subklasse.
Deze afgeleide klasse in C# neemt niet alleen eigenschappen van de basisklasse over, maar kan ook zijn eigen unieke kenmerken toevoegen.
Hoe werkt overerving in C#
In C# wordt overerving bereikt door het gebruik van de dubbele punt (:) symbool. De naam van de basisklasse wordt gedefinieerd na de dubbele punt en wordt gespecificeerd door de afgeleide klasse.
Het volgende is de syntaxis voor het maken van een afgeleide klasse die eigenschappen van de basisklasse overneemt:
klasse Afgeleide klasse : Basisklasse{
// afgeleide klasleden
}
Hier in deze code, Afgeleide klasse is de naam van de afgeleide klasse, en Basisklasse is de naam van de basisklasse. De : symbool geeft aan dat DerivedClass erft van BaseClass. De leden van DerivedClass hebben toegang tot BaseClass-leden, op voorwaarde dat ze niet privé zijn.
Soorten overerving in C#
C# ondersteunt vier soorten overerving: enkele, meerdere niveaus, hiërarchische en meervoudige overerving. Laten we naar elk type kijken.
Enkele erfenis
Enkelvoudige overerving is het meest voorkomende type overerving, waarbij een afgeleide klasse eigenschappen overneemt of overerft van slechts één enkele basisklasse.
Bijvoorbeeld, de gegeven code legt de klassenhiërarchie uit en demonstreert overervingsconcepten.
systeem gebruiken ;systeem gebruiken ;
klasse auto
{
openbaar leegte Begin ( )
{
Troosten. Schrijf lijn ( 'Auto gestart' ) ;
}
}
klasse Tesla : Auto
{
openbaar leegte Versnellen ( )
{
Troosten. Schrijf lijn ( 'Tesla accelereert' ) ;
}
}
klasse programma
{
statisch leegte Voornaamst ( snaar [ ] argumenten )
{
Tesla mijnTesla = nieuwe Tesla ( ) ;
mijnTesla. Begin ( ) ; // Uitvoer: auto gestart
mijnTesla. Versnellen ( ) ; // Output: Tesla accelereert
}
}
In de bovenstaande code is de Auto klasse is de basisklasse en heeft een methode genaamd Begin() , waarmee het bericht eenvoudig wordt afgedrukt Auto gestart naar de console.
De Tesla klasse is afgeleid van de klasse Car en heeft alle eigenschappen van de klasse Car. De klasse Tesla voegt een methode toe met de naam Versnellen() , waarmee het bericht wordt afgedrukt Tesla accelereert naar de console.
De Voornaamst() functie definieert een instantie van de aangeroepen Tesla-klasse mijnTesla en roept de methoden Start() en Accelerate() aan.
Overerving op meerdere niveaus
Multi-level overerving is waar een afgeleide klasse erft van een andere afgeleide klasse, die op zijn beurt erft van een basisklasse.
Bijvoorbeeld, de volgende C#-code demonstreert overerving en methode-overheersing in een klassenhiërarchie.
systeem gebruiken ;klasse dier
{
openbaar leegte Eten ( )
{
Troosten. Schrijf lijn ( 'Dieren eten' ) ;
}
}
klasse Zoogdier : Dier
{
openbaar leegte Loop ( )
{
Troosten. Schrijf lijn ( 'Zoogdier rennen' ) ;
}
}
klasse Hond : Zoogdier
{
openbaar leegte Blaffen ( )
{
Troosten. Schrijf lijn ( 'Blaffende hond' ) ;
}
}
klasse programma
{
statisch leegte Voornaamst ( snaar [ ] argumenten )
{
Hond mijn Hond = nieuwe Hond ( ) ;
mijn hond. Eten ( ) ; // Output: Dieren eten
mijn hond. Loop ( ) ; // Uitvoer: rennende zoogdieren
mijn hond. Blaffen ( ) ; // Output: blaffende hond
}
}
Hier Hond is een afgeleide klasse die erft van Zoogdier , die op zijn beurt erft van Dier . De klasse Dog heeft toegang tot alle eigenschappen, methoden en gedragingen van Mammal en Animal en kan ook zijn eigen unieke methode definiëren Blaffen() .
De Dierlijke klasse is de basisklasse en heeft een methode genaamd Eten() , waarmee eenvoudig het bericht Animal eating naar de console wordt afgedrukt.
De Zoogdier klasse is afgeleid van de klasse Animal en voegt een methode toe genaamd Loop() , waarmee het bericht Mammal wordt afgedrukt dat naar de console rent.
De Honden klasse is afgeleid van de klasse Mammal en voegt een methode toe genaamd Blaffen() , waarmee het bericht Hond blaft naar de console wordt afgedrukt.
De methode Main() maakt een instantie van de klasse Dog genaamd mijn hond en roept de methoden Eat(), Run() en Bark() aan.
Merk op dat de methoden Eat() en Run() niet zijn gedefinieerd in de klasse Dog, maar zijn geërfd van de bovenliggende klassen Dier En Zoogdier , respectievelijk. De Blaffen() methode wordt alleen gedefinieerd in de klasse Dog.
Hiërarchische erfenis
Bij hiërarchische overerving worden verschillende aantallen afgeleide klassen geërfd van slechts één basisklasse. Bijvoorbeeld:
systeem gebruiken ;klasse Vorm
{
openbaar leegte Tekenen ( )
{
Troosten. Schrijf lijn ( 'Vorm tekenen' ) ;
}
}
klasse Cirkel : Vorm
{
openbaar leegte Vullen ( )
{
Troosten. Schrijf lijn ( 'Vul cirkel' ) ;
}
}
klasse Vierkant : Vorm
{
openbaar leegte Kleur ( )
{
Troosten. Schrijf lijn ( 'Kleurplaat' ) ;
}
}
klasse programma
{
statisch leegte Voornaamst ( snaar [ ] argumenten )
{
Omcirkel mijnKring = nieuwe Cirkel ( ) ;
mijnKring. Tekenen ( ) ; // Uitvoer: tekenvorm
mijnKring. Vullen ( ) ; // Uitvoer: cirkel vullen
Vierkant mijnVierkant = nieuw Plein ( ) ;
mijnVierkant. Tekenen ( ) ; // Uitvoer: tekenvorm
mijnVierkant. Kleur ( ) ; // Uitvoer: Kleurvierkant
}
}
In de bovenstaande code, beide Cirkel En Vierkant zijn afgeleide klassen die erven van Vorm . Ze hebben toegang tot de methode Draw() die is gedefinieerd in Shape en kunnen ook hun eigen unieke methoden Fill() en Color() definiëren.
Hier hebben we een object gemaakt van de klasse Circle genaamd mijnKring en een voorwerp van de Vierkant klasse genoemd mijnVierkant . Wij bellen dan de Tekenen() methode, die is geërfd van de klasse Shape, op beide objecten.
Vervolgens bellen we de Vullen() methode op myCircle, die specifiek is voor de klasse Circle, en de Kleur() methode op mySquare, die specifiek is voor de square-klasse.
De uitvoer wordt als volgt naar de console afgedrukt:
Meervoudige erfenis
Bij meervoudige overerving erft een afgeleide klasse van meerdere basisklassen. C# ondersteunt echter geen meervoudige overerving. Om vergelijkbare functionaliteit te bereiken, gebruikt C# interfaces .
Conclusie
Door overerving in C# kunnen klassen gedrag en functionaliteit overnemen van basisklassen. Door overerving te gebruiken, kunnen we code hergebruiken en een hiërarchische stroom binnen het programma creëren. Door de verschillende soorten overerving te begrijpen, kan men efficiëntere en georganiseerde code schrijven die gemakkelijker te onderhouden en uit te breiden is.