Taula de continguts
Què és l'herència en C#
En C# utilitzant l'herència, una classe pot prendre o heretar les propietats i mètodes d'una altra classe. En altres paraules, permet la creació d'una nova classe basada en una classe existent, que es coneix com a classe base o superclasse. S'anomena una classe formada després de prendre les propietats d'una classe base una classe derivada o subclasse.
Aquesta classe derivada en C# no només pren propietats de la classe base, sinó que també pot afegir les seves pròpies característiques úniques.
Com funciona l'herència en C#
En C#, l'herència s'aconsegueix mitjançant l'ús dels dos punts (:) símbol. El nom de la classe base es defineix després dels dos punts i la classe derivada l'especifica.
La següent és la sintaxi per crear una classe derivada que pren propietats de la classe base:
classe DerivedClass : Classe base{
// membres de classe derivats
}
Aquí en aquest codi, Classe derivada és el nom de la classe derivada i Classe base és el nom de la classe base. El : El símbol indica que DerivedClass està heretant de BaseClass. Els membres de DerivedClass poden accedir als membres de BaseClass, sempre que no siguin privats.
Tipus d'herència en C#
C# admet quatre tipus d'herència: herència única, multinivell, jeràrquica i múltiple. Vegem cada tipus.
Herència única
L'herència única és el tipus d'herència més comú, on una classe derivada pren o hereta propietats d'una sola classe base.
Per exemple, el codi donat explica la jerarquia de classes i demostra els conceptes d'herència.
utilitzant System ;utilitzant System ;
Cotxe de classe
{
públic buit Començar ( )
{
Consola. WriteLine ( 'El cotxe va començar' ) ;
}
}
classe Tesla : Cotxe
{
públic buit Accelerar ( )
{
Consola. WriteLine ( 'Tesla accelerant' ) ;
}
}
programa de classe
{
estàtica buit Principal ( corda [ ] args )
{
Tesla myTesla = nou Tesla ( ) ;
la meva Tesla. Començar ( ) ; // Sortida: cotxe engegat
la meva Tesla. Accelerar ( ) ; // Sortida: Tesla accelerant
}
}
En el codi anterior, el Classe de cotxes és la classe base i té un mètode anomenat Començar() , que simplement imprimeix el missatge El cotxe va començar a la consola.
El Classe Tesla deriva de la classe Car i pren totes les propietats de la classe Car. La classe Tesla afegeix un mètode anomenat Accelerar () , que imprimeix el missatge Tesla accelerant a la consola.
El Principal() La funció defineix una instància de la classe Tesla anomenada la meva Tesla i crida als seus mètodes Start() i Accelerate().
Herència multinivell
L'herència multinivell és quan una classe derivada hereta d'una altra classe derivada, que al seu torn hereta d'una classe base.
Per exemple, el codi C# següent demostra l'herència i la substitució del mètode en una jerarquia de classes.
utilitzant System ;classe Animal
{
públic buit Menja ( )
{
Consola. WriteLine ( 'Menjar animals' ) ;
}
}
classe Mamífer : Animal
{
públic buit Correr ( )
{
Consola. WriteLine ( 'Mamífer corrent' ) ;
}
}
classe Gos : Mamífer
{
públic buit Escorça ( )
{
Consola. WriteLine ( 'El gos bordant' ) ;
}
}
programa de classe
{
estàtica buit Principal ( corda [ ] args )
{
Dog myDog = gos nou ( ) ;
el meu gos. Menja ( ) ; // Sortida: Menjar animals
el meu gos. Correr ( ) ; // Sortida: mamífer corrent
el meu gos. Escorça ( ) ; // Sortida: gos bordant
}
}
Aquí gos és una classe derivada que hereta de Mamífer , que al seu torn hereta de Animal . La classe Dog té accés a totes les propietats, mètodes i comportament de Mamífer i Animal, i també pot definir el seu propi mètode únic escorça () .
El Classe d'animals és la classe base i té un mètode anomenat Menjar () , que simplement imprimeix el missatge Animal menjant a la consola.
El Classe de mamífers es deriva de la classe Animal i afegeix un mètode anomenat Correr() , que imprimeix el missatge Mammal running a la consola.
El Classe de gossos deriva de la classe Mammal i afegeix un mètode anomenat escorça () , que imprimeix el missatge Gos bordant a la consola.
El mètode Main() crea una instància de la classe Dog anomenada el meu gos i crida als seus mètodes Eat(), Run() i Bark().
Tingueu en compte que els mètodes Eat() i Run() no es defineixen a la classe Dog, sinó que s'hereten de les seves classes pare. Animal i Mamífer , respectivament. El escorça () El mètode només es defineix a la classe Dog.
Herència jeràrquica
En l'herència jeràrquica, s'hereten diferents nombres de classes derivades d'una sola classe base. Per exemple:
utilitzant System ;Forma de classe
{
públic buit Dibuixa ( )
{
Consola. WriteLine ( 'Forma de dibuix' ) ;
}
}
cercle de classe : Forma
{
públic buit Omplir ( )
{
Consola. WriteLine ( 'Omplint el cercle' ) ;
}
}
Plaça de classe : Forma
{
públic buit Color ( )
{
Consola. WriteLine ( 'Quadrat per pintar' ) ;
}
}
programa de classe
{
estàtica buit Principal ( corda [ ] args )
{
Encercla el meuCircle = nou cercle ( ) ;
el meuCircle. Dibuixa ( ) ; // Sortida: Forma de dibuix
el meuCircle. Omplir ( ) ; // Sortida: Omplint cercle
Square mySquare = nova plaça ( ) ;
mySquare. Dibuixa ( ) ; // Sortida: Forma de dibuix
mySquare. Color ( ) ; // Sortida: quadrat per pintar
}
}
En el codi anterior, tots dos Cercle i Quadrat són classes derivades que hereten de Forma . Tenen accés al mètode Draw() definit a Shape i també poden definir els seus propis mètodes únics Fill() i Color().
Aquí hem creat un objecte de la classe Circle anomenat el meuCircle i un objecte de la Quadrat classe anomenada mySquare . Aleshores anomenem el Dibuixa () mètode, que s'hereta de la classe Shape, en ambdós objectes.
A continuació, anomenem el Omplir () mètode a myCircle, que és específic de la classe Circle, i el Color() mètode a mySquare, que és específic de la classe quadrat.
La sortida s'imprimirà a la consola de la següent manera:
Herència múltiple
L'herència múltiple és quan una classe derivada hereta de diverses classes base. Tanmateix, C# no admet l'herència múltiple. Per aconseguir una funcionalitat similar, utilitza C# interfícies .
Conclusió
L'herència en C# permet que les classes heretin el comportament i la funcionalitat de les classes base. Mitjançant l'herència, podem reutilitzar codi i crear un flux jeràrquic dins del programa. En entendre els diferents tipus d'herència, es pot escriure un codi més eficient i organitzat que sigui més fàcil de mantenir i ampliar.