Tartalomjegyzék
Hogyan működik az öröklődés a C#-ban
- Egyetlen öröklődés
- Többszintű öröklődés
- Hierarchikus öröklődés
- Többszörös öröklés (nem támogatott a C#-ban)
Mi az öröklődés a C#-ban
Az öröklődést használó C#-ban egy osztály átveheti vagy örökölheti egy másik osztály tulajdonságait és metódusait. Más szóval, lehetővé teszi egy új osztály létrehozását egy meglévő osztály alapján, amelyet alaposztálynak vagy szuperosztálynak nevezünk. Az alaposztály tulajdonságainak felvétele után létrejött osztályt nevezzük származtatott osztály vagy alosztály.
Ez a származtatott osztály a C#-ban nem csak az alaposztály tulajdonságait veszi fel, hanem saját egyedi jellemzőit is hozzáadhatja.
Hogyan működik az öröklődés a C#-ban
A C#-ban az öröklődés a vastagbél használatával történik (:) szimbólum. Az alaposztály nevét a kettőspont után adjuk meg, és a származtatott osztály adja meg.
A következő a szintaxis egy származtatott osztály létrehozásához, amely az alaposztály tulajdonságait veszi át:
osztály DerivedClass : BaseClass{
// származtatott osztálytagok
}
Itt ebben a kódban DerivedClass a származtatott osztály neve, és BaseClass az alaposztály neve. A : szimbólum azt jelzi, hogy a DerivedClass a BaseClass-tól örököl. A DerivedClass tagjai hozzáférhetnek a BaseClass-tagokhoz, feltéve, hogy nem privátak.
Az öröklődés típusai a C#-ban
A C# négyféle öröklődést támogat: egy-, többszintű, hierarchikus és többszörös öröklődést. Nézzük meg az egyes típusokat.
Egyetlen öröklődés
Az egyszeres öröklődés az öröklődés leggyakoribb típusa, ahol egy származtatott osztály csak egyetlen alaposztály tulajdonságait veszi fel vagy örökli.
Például, az adott kód elmagyarázza az osztályhierarchiát és bemutatja az öröklődési fogalmakat.
rendszer segítségével ;rendszer segítségével ;
osztályú Autó
{
nyilvános üres Rajt ( )
{
Konzol. WriteLine ( 'Elindult az autó' ) ;
}
}
osztályú Tesla : Autó
{
nyilvános üres Gyorsítson ( )
{
Konzol. WriteLine ( 'Gyorsul a Tesla' ) ;
}
}
osztály Programja
{
statikus üres Fő ( húr [ ] args )
{
Tesla myTesla = új Tesla ( ) ;
myTesla. Rajt ( ) ; // Kimenet: Az autó elindult
myTesla. Gyorsítson ( ) ; // Kimenet: Tesla gyorsul
}
}
A fenti kódban a Autó osztály az alaposztály, és van egy nevű metódusa Rajt() , amely egyszerűen kinyomtatja az üzenetet Beindult az autó a konzolhoz.
A Tesla osztály az autó osztályból származik, és az autó osztály összes tulajdonságát átveszi. A Tesla osztály hozzáad egy metódust, az úgynevezett Gyorsítás() , amely kinyomtatja az üzenetet A Tesla gyorsul a konzolhoz.
A Fő() függvény a Tesla osztály egy példányát határozza meg myTesla és meghívja a Start() és Accelerate() metódusait.
Többszintű öröklődés
A többszintű öröklődés az, amikor egy származtatott osztály egy másik származtatott osztálytól örököl, amely viszont egy alaposztálytól örököl.
Például, a következő C# kód az öröklődést és a metódus felülbírálását mutatja be egy osztályhierarchiában.
rendszer segítségével ;osztály Állat
{
nyilvános üres Eszik ( )
{
Konzol. WriteLine ( 'Állati evés' ) ;
}
}
osztály Emlős : Állat
{
nyilvános üres Fuss ( )
{
Konzol. WriteLine ( 'Emlős futás' ) ;
}
}
osztályú Kutya : Emlős
{
nyilvános üres Ugat ( )
{
Konzol. WriteLine ( 'Kutya ugatás' ) ;
}
}
osztály Programja
{
statikus üres Fő ( húr [ ] args )
{
Kutya myDog = új kutya ( ) ;
kutyám. Eszik ( ) ; // Kimenet: Állatevés
kutyám. Fuss ( ) ; // Kimenet: Futó emlős
kutyám. Ugat ( ) ; // Kimenet: Kutyaugatás
}
}
Itt Kutya egy származtatott osztály, amelyből öröklődik Emlős , ami viszont abból öröklődik Állat . A Kutya osztály hozzáfér az emlősök és állatok összes tulajdonságához, módszeréhez és viselkedéséhez, és meg tudja határozni saját egyedi módszerét is. Ugat() .
A Állat osztály az alaposztály, és van egy nevű metódusa Eszik() , amely egyszerűen kiírja a konzolra az Animal eats üzenetet.
A Emlős osztály Az Animal osztályból származik, és hozzáad egy metódust Fuss() , amely a Mammal running üzenetet írja ki a konzolra.
A Kutya osztály az emlős osztályból származik, és hozzáad egy ún Ugat() , amely a Kutyaugatás üzenetet írja ki a konzolra.
A Main() metódus létrehozza a Dog osztály egy példányát kutyám és meghívja az Eat(), Run() és Bark() metódusait.
Ne feledje, hogy az Eat() és Run() metódusok nincsenek definiálva a Dog osztályban, hanem a szülőosztályaiból öröklődnek. Állat és Emlős , ill. A Ugat() metódus csak a Dog osztályban van definiálva.
Hierarchikus öröklődés
A hierarchikus öröklődésben különböző számú származtatott osztály öröklődik csak egy alaposztályból. Például:
rendszer segítségével ;osztály Forma
{
nyilvános üres Húz ( )
{
Konzol. WriteLine ( 'Rajz alakzat' ) ;
}
}
osztályos Kör : Alak
{
nyilvános üres Tölt ( )
{
Konzol. WriteLine ( 'Kitöltő kör' ) ;
}
}
osztályú tér : Alak
{
nyilvános üres Szín ( )
{
Konzol. WriteLine ( 'Színező négyzet' ) ;
}
}
osztály Programja
{
statikus üres Fő ( húr [ ] args )
{
Circle myCircle = új Kör ( ) ;
myCircle. Húz ( ) ; // Kimenet: Rajz alakzat
myCircle. Tölt ( ) ; // Kimenet: Kör kitöltése
Négyzet alakú mySquare = új tér ( ) ;
mySquare. Húz ( ) ; // Kimenet: Rajz alakzat
mySquare. Szín ( ) ; // Kimenet: négyzet színezése
}
}
A fenti kódban mindkettő Kör és Négyzet származtatott osztályok, amelyektől öröklődnek Alak . Hozzáférhetnek a Shape-ban definiált Draw() metódushoz, és saját egyedi metódusaikat is meghatározhatják a Fill() és a Color().
Itt létrehoztuk a Circle osztály nevű objektumát myCircle és tárgya a Négyzet osztály neve mySquare . Ezután hívjuk a Húz() metódus, amely a Shape osztályból öröklődik, mindkét objektumon.
Ezután hívjuk a Tölt() metódus a myCircle-en, amely a Circle osztályra jellemző, és a Szín() metódus a mySquare-en, amely a négyzet osztályra jellemző.
A kimenet az alábbiak szerint kerül kinyomtatásra a konzolra:
Többszörös öröklés
A többszörös öröklődés az, amikor egy származtatott osztály több alaposztályból örököl. A C# azonban nem támogatja a többszörös öröklődést. Hasonló funkciók eléréséhez a C# használja interfészek .
Következtetés
A C#-ban az öröklődés lehetővé teszi, hogy az osztályok viselkedést és funkcionalitást örököljenek az alaposztályoktól. Az öröklődés segítségével újra felhasználhatjuk a kódot, és hierarchikus folyamatot hozhatunk létre a programon belül. Az öröklődés különböző típusainak megértésével hatékonyabb és szervezettebb kód írható, amelyet könnyebb karbantartani és kiterjeszteni.