Innholdsfortegnelse
Hva er arv i C#
I C# ved bruk av arv, kan en klasse ta eller arve egenskapene og metodene til en annen klasse. Med andre ord tillater det å lage en ny klasse basert på en eksisterende klasse, som er kjent som basisklassen eller superklassen. En klasse dannet etter å ha tatt egenskapene til en basisklasse kalles en avledet klasse eller underklasse.
Denne avledede klassen i C# tar ikke bare egenskaper til basisklassen, men kan også legge til sine egne unike funksjoner.
Hvordan fungerer arv i C#
I C# oppnås arv gjennom bruk av kolon (:) symbol. Basisklassenavnet er definert etter kolon, og det spesifiseres av den avledede klassen.
Følgende er syntaksen for å lage en avledet klasse som tar egenskaper fra basisklassen:
klasse DerivedClass : BaseClass{
// avledede klassemedlemmer
}
Her i denne koden, Avledet Klasse er navnet på den avledede klassen, og BaseClass er navnet på basisklassen. De : symbolet indikerer at DerivedClass arver fra BaseClass. Medlemmene av DerivedClass kan få tilgang til BaseClass-medlemmer, forutsatt at de ikke er private.
Typer av arv i C#
C# støtter fire typer arv: enkelt, flernivå, hierarkisk og multippel arv. La oss se på hver type.
Enkeltarv
Enkeltarv er den vanligste arvetypen, der en avledet klasse tar eller arver egenskaper til kun en enkelt basisklasse.
For eksempel, den gitte koden forklarer klassehierarki og demonstrerer arvebegreper.
bruker System ;bruker System ;
klasse bil
{
offentlig tomrom Start ( )
{
Konsoll. WriteLine ( 'Bil startet' ) ;
}
}
klasse Tesla : Bil
{
offentlig tomrom Akselerere ( )
{
Konsoll. WriteLine ( 'Tesla akselererer' ) ;
}
}
klasseprogram
{
statisk tomrom Hoved ( streng [ ] args )
{
Tesla myTesla = nye Tesla ( ) ;
minTesla. Start ( ) ; // Utgang: Bil startet
minTesla. Akselerere ( ) ; // Utgang: Tesla akselererer
}
}
I koden ovenfor er det Bilklasse er basisklassen og har en metode kalt Start() , som ganske enkelt skriver ut meldingen Bilen startet til konsollen.
De Tesla klasse er avledet fra Bil-klassen, og den tar alle egenskaper i Bil-klassen. Tesla-klassen legger til en metode kalt Akselerere() , som skriver ut meldingen Tesla akselererer til konsollen.
De Hoved() funksjonen definerer en forekomst av Tesla-klassen kalt minTesla og kaller metodene Start() og Accelerate().
Arv på flere nivåer
Flernivåarv er der en avledet klasse arver fra en annen avledet klasse, som igjen arver fra en basisklasse.
For eksempel, følgende C#-kode demonstrerer arv og metodeoverstyring i et klassehierarki.
bruker System ;klasse Dyr
{
offentlig tomrom Spise ( )
{
Konsoll. WriteLine ( 'Dyrespising' ) ;
}
}
klasse Pattedyr : Dyr
{
offentlig tomrom Løpe ( )
{
Konsoll. WriteLine ( 'Pattedyr som løper' ) ;
}
}
klasse hund : Pattedyr
{
offentlig tomrom Bark ( )
{
Konsoll. WriteLine ( 'Hunde bjeffing' ) ;
}
}
klasseprogram
{
statisk tomrom Hoved ( streng [ ] args )
{
Dog myDog = ny hund ( ) ;
min hund. Spise ( ) ; // Utgang: Dyrespising
min hund. Løpe ( ) ; // Utgang: Pattedyr kjører
min hund. Bark ( ) ; // Utgang: Hundebjeffer
}
}
Her Hund er en avledet klasse som arver fra Pattedyr , som igjen arver fra Dyr . Hundeklassen har tilgang til alle egenskapene, metodene og oppførselen til pattedyr og dyr, og kan også definere sin egen unike metode Bark() .
De Dyreklasse er basisklassen og har en metode kalt Spise() , som ganske enkelt skriver ut meldingen Animal eating til konsollen.
De Pattedyrklasse er avledet fra Animal-klassen og legger til en metode kalt Løpe() , som skriver ut meldingen Mammal running til konsollen.
De Hundeklasse er avledet fra Mammal-klassen og legger til en metode kalt Bark() , som skriver ut meldingen Dog barking til konsollen.
Main()-metoden oppretter en forekomst av Dog-klassen kalt min hund og kaller Eat(), Run() og Bark()-metodene.
Merk at metodene Eat() og Run() ikke er definert i Dog-klassen, men arves fra dens overordnede klasser Dyr og Pattedyr , henholdsvis. De Bark() metoden er kun definert i hundeklassen.
Hierarkisk arv
I hierarkisk arv arves forskjellige antall avledede klasser fra bare én basisklasse. For eksempel:
bruker System ;klasse Form
{
offentlig tomrom Tegne ( )
{
Konsoll. WriteLine ( 'Tegne form' ) ;
}
}
klassesirkel : Form
{
offentlig tomrom Fylle ( )
{
Konsoll. WriteLine ( 'Fylle sirkel' ) ;
}
}
klasse Square : Form
{
offentlig tomrom Farge ( )
{
Konsoll. WriteLine ( 'Fargelegg kvadrat' ) ;
}
}
klasseprogram
{
statisk tomrom Hoved ( streng [ ] args )
{
Circle myCircle = ny sirkel ( ) ;
min krets. Tegne ( ) ; // Output: Tegne form
min krets. Fylle ( ) ; // Utgang: Fyllingssirkel
Square mySquare = nytt torg ( ) ;
mySquare. Tegne ( ) ; // Output: Tegne form
mySquare. Farge ( ) ; // Utgang: Fargelegg firkant
}
}
I koden ovenfor, begge Sirkel og Torget er avledede klasser som arver fra Form . De har tilgang til Draw()-metoden definert i Shape og kan også definere sine egne unike metoder Fill() og Color().
Her har vi laget et objekt av Circle-klassen kalt min krets og et objekt av Torget klasse navngitt mySquare . Vi ringer da Tegne() metoden, som er arvet fra Shape-klassen, på begge objektene.
Deretter kaller vi Fylle() metoden på myCircle, som er spesifikk for Circle-klassen, og Farge() metode på mySquare, som er spesifikk for kvadratklassen.
Utdataene vil bli skrevet ut til konsollen som nedenfor:
Multippel arv
Multippel arv er der en avledet klasse arver fra flere basisklasser. C# støtter imidlertid ikke multippel arv. For å oppnå lignende funksjonalitet bruker C# grensesnitt .
Konklusjon
Arv i C# lar klasser arve atferd og funksjonalitet fra basisklasser. Ved å bruke arv kan vi gjenbruke kode og lage en hierarkisk flyt inne i programmet. Ved å forstå de ulike arvetypene kan man skrive mer effektiv og organisert kode som er lettere å vedlikeholde og utvide.