Table des matières
Qu'est-ce que l'héritage en C#
Comment fonctionne l'héritage en C#
- Héritage unique
- Héritage à plusieurs niveaux
- Héritage hiérarchique
- Héritage multiple (non pris en charge en C#)
Qu'est-ce que l'héritage en C#
En C# utilisant l'héritage, une classe peut prendre ou hériter des propriétés et des méthodes d'une autre classe. En d'autres termes, il permet la création d'une nouvelle classe basée sur une classe existante, appelée classe de base ou super classe. Une classe formée après avoir pris les propriétés d'une classe de base est appelée une classe dérivée ou sous-classe.
Cette classe dérivée en C # prend non seulement les propriétés de la classe de base, mais peut également ajouter ses propres fonctionnalités uniques.
Comment fonctionne l'héritage en C#
En C #, l'héritage est obtenu grâce à l'utilisation des deux-points (:) symbole. Le nom de la classe de base est défini après les deux-points et est spécifié par la classe dérivée.
Voici la syntaxe de création d'une classe dérivée qui prend les propriétés de la classe de base :
classe DerivedClass : Classe de base{
// membres de classe dérivés
}
Ici dans ce code, Classe dérivée est le nom de la classe dérivée, et Classe de base est le nom de la classe de base. Le : indique que DerivedClass hérite de BaseClass. Les membres de DerivedClass peuvent accéder aux membres de BaseClass, à condition qu'ils ne soient pas privés.
Types d'héritage en C#
C# prend en charge quatre types d'héritage : héritage unique, multiniveau, hiérarchique et multiple. Examinons chaque type.
Héritage unique
L'héritage unique est le type d'héritage le plus courant, dans lequel une classe dérivée prend ou hérite des propriétés d'une seule classe de base.
Par exemple, le code donné explique la hiérarchie des classes et démontre les concepts d'héritage.
en utilisant le système ;en utilisant le système ;
voiture de classe
{
public annuler Commencer ( )
{
Console. WriteLine ( 'Voiture démarrée' ) ;
}
}
classe Tesla : Voiture
{
public annuler Accélérer ( )
{
Console. WriteLine ( 'Tesla accélère' ) ;
}
}
Programme de classe
{
statique annuler Principal ( chaîne [ ] arguments )
{
Tesla myTesla = nouvelle Tesla ( ) ;
maTesla. Commencer ( ) ; // Sortie : voiture démarrée
maTesla. Accélérer ( ) ; // Sortie : Tesla en accélération
}
}
Dans le code ci-dessus, le Classe de voiture est la classe de base et a une méthode appelée Commencer() , qui imprime simplement le message La voiture a démarré à la console.
Le Classe Tesla est dérivé de la classe Car et prend toutes les propriétés de la classe Car. La classe Tesla ajoute une méthode appelée Accélérer() , qui imprime le message Tesla accélère à la console.
Le Principal() La fonction définit une instance de la classe Tesla appelée maTesla et appelle ses méthodes Start() et Accelerate().
Héritage à plusieurs niveaux
L'héritage à plusieurs niveaux est l'endroit où une classe dérivée hérite d'une autre classe dérivée, qui à son tour hérite d'une classe de base.
Par exemple, le code C# suivant illustre l'héritage et le remplacement de méthode dans une hiérarchie de classes.
en utilisant le système ;classe Animaux
{
public annuler Manger ( )
{
Console. WriteLine ( 'Manger des animaux' ) ;
}
}
classe Mammifère : Animal
{
public annuler Courir ( )
{
Console. WriteLine ( 'Mammifère qui court' ) ;
}
}
Chien de classe : Mammifère
{
public annuler Aboyer ( )
{
Console. WriteLine ( 'Aboiement de chien' ) ;
}
}
Programme de classe
{
statique annuler Principal ( chaîne [ ] arguments )
{
Chien myDog = nouveau chien ( ) ;
mon chien. Manger ( ) ; // Sortie : Manger des animaux
mon chien. Courir ( ) ; // Sortie : Mammifère en cours d'exécution
mon chien. Aboyer ( ) ; // Sortie : Chien qui aboie
}
}
Ici Chien est une classe dérivée qui hérite de Mammifère , qui hérite à son tour de Animal . La classe Dog a accès à toutes les propriétés, méthodes et comportements de Mammal et Animal, et peut également définir sa propre méthode unique Aboyer() .
Le Classe d'animaux est la classe de base et a une méthode appelée Manger() , qui imprime simplement le message Animal mangeant sur la console.
Le Classe de mammifères est dérivé de la classe Animal et ajoute une méthode appelée Courir() , qui imprime le message Mammal running sur la console.
Le Classe de chien est dérivé de la classe Mammal et ajoute une méthode appelée Aboyer() , qui imprime le message Chien qui aboie sur la console.
La méthode Main() crée une instance de la classe Dog appelée mon chien et appelle ses méthodes Eat(), Run() et Bark().
Notez que les méthodes Eat() et Run() ne sont pas définies dans la classe Dog, mais sont héritées de ses classes parentes Animal et Mammifère , respectivement. Le Aboyer() La méthode n'est définie que dans la classe Dog.
Héritage hiérarchique
Dans l'héritage hiérarchique, différents nombres de classes dérivées sont héritées d'une seule classe de base. Par exemple:
en utilisant le système ;forme de classe
{
public annuler Dessiner ( )
{
Console. WriteLine ( 'Forme du dessin' ) ;
}
}
cercle de classe : Forme
{
public annuler Remplir ( )
{
Console. WriteLine ( 'Remplir le cercle' ) ;
}
}
carré de classe : Forme
{
public annuler Couleur ( )
{
Console. WriteLine ( 'Carré de coloriage' ) ;
}
}
Programme de classe
{
statique annuler Principal ( chaîne [ ] arguments )
{
Cercle monCercle = nouveau cercle ( ) ;
monCercle. Dessiner ( ) ; // Sortie : forme de dessin
monCercle. Remplir ( ) ; // Sortie : Remplir le cercle
Carré monSquare = nouveau carré ( ) ;
monSquare. Dessiner ( ) ; // Sortie : forme de dessin
monSquare. Couleur ( ) ; // Sortie : Carré de coloration
}
}
Dans le code ci-dessus, les deux Cercle et Carré sont des classes dérivées qui héritent de Forme . Ils ont accès à la méthode Draw() définie dans Shape et peuvent également définir leurs propres méthodes uniques Fill() et Color().
Ici, nous avons créé un objet de la classe Circle nommé monCercle et un objet de Carré classe nommée monSquare . On appelle alors le Dessiner() , qui est héritée de la classe Shape, sur les deux objets.
Ensuite, nous appelons le Remplir() sur myCircle, qui est spécifique à la classe Circle, et la Couleur() sur mySquare, qui est spécifique à la classe square.
La sortie sera imprimée sur la console comme ci-dessous :
Héritage multiple
L'héritage multiple est l'endroit où une classe dérivée hérite de plusieurs classes de base. Cependant, C# ne prend pas en charge l'héritage multiple. Pour obtenir des fonctionnalités similaires, C # utilise interfaces .
Conclusion
L'héritage en C# permet aux classes d'hériter du comportement et des fonctionnalités des classes de base. En utilisant l'héritage, nous pouvons réutiliser le code et créer un flux hiérarchique à l'intérieur du programme. En comprenant les différents types d'héritage, on peut écrire un code plus efficace et organisé, plus facile à maintenir et à étendre.