Comment utiliser l'héritage en C #
Table des matières
Quel est l'héritage en C #
Comment fonctionne l'héritage en C #
Types d'héritage en C #
- Héritage unique
- Héritage à plusieurs niveaux
- Héritage hiérarchique
- Héritage multiple (non pris en charge en C #)
Conclusion
Quel est l'héritage en C #
En C # en utilisant l'héritage, une classe peut suivre 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, connue sous le nom de classe de base ou de 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 des 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 réalisé grâce à l'utilisation du côlon (:) symbole. Le nom de la classe de base est défini après le côlon, et il est spécifié par la classe dérivée.
Ce qui suit est la syntaxe pour créer une classe dérivée qui prend des propriétés de la classe de base:
classe DerivedClass: BaseClass// membres de la 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 : Le symbole indique que la classe dérivée est héritée 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: célibataire, multi-niveaux, hiérarchique et héritage multiple. Regardons chaque type.
Héritage unique
L'héritage unique est le type d'héritage le plus courant, où 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 des concepts d'héritage.
Utilisation du système;Utilisation du système;
voiture de classe
public void start ()
Console.WriteLine ("Car démarrée");
classe Tesla: voiture
public void Accelerate ()
Console.WriteLine ("Tesla accélérer");
programme de classe
statique void main (String [] args)
Tesla mytesla = new Tesla ();
mytesla.Commencer(); // Sortie: la voiture a démarré
mytesla.Accélérer(); // Sortie: Tesla 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 commencé à la console.
Le Classe Tesla est dérivé de la classe de voiture, et il prend toutes les propriétés de la classe de voiture. La classe Tesla ajoute une méthode appelée Accélérer(), qui imprime le message Tesla accélérer à la console.
Le Principal() La fonction définit une instance de la classe Tesla appelée mytesla et appelle ses méthodes start () et accélérer ().
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 démontre l'héritage et la méthode remplacée dans une hiérarchie de classe.
Utilisation du système;animal de classe
public void Eat ()
Console.Writeline ("alimentation animale");
Mammifère de classe: Animal
public void run ()
Console.WriteLine ("Running Mammal");
chien de classe: mammifère
Écorce public public ()
Console.Writeline ("Barking de chien");
programme de classe
statique void main (String [] args)
Chien mydog = new dog ();
mon chien.Manger(); // Sortie: alimentation animale
mon chien.Courir(); // Sortie: Mammifère Running
mon chien.Aboyer(); // Sortie: aboiement de chien
Ici Chien est une classe dérivée qui hérite de Mammifère, qui à son tour hérite de Animal. La classe de chiens a accès à toutes les propriétés, méthodes et comportements des mammifères et des animaux, et peut également définir sa propre méthode unique Aboyer().
Le Classe animale est la classe de base et a une méthode appelée Manger(), qui imprime simplement le message animal qui mange à la console.
Le Classe de mammifères est dérivé de la classe animale et ajoute une méthode appelée Courir(), qui imprime le message mammifère qui coule vers la console.
Le Classe de chiens est dérivé de la classe des mammifères et ajoute une méthode appelée Aboyer(), qui imprime le messier aboyant à la console.
La méthode principale () crée une instance de la classe de chiens 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 de chiens, mais sont héritées de ses classes de parents Animal et Mammifère, respectivement. Le Aboyer() La méthode n'est définie que dans la classe de chiens.
Héritage hiérarchique
Dans l'héritage hiérarchique, différents nombres de classes dérivés sont hérités d'une seule classe de base. Par exemple:
Utilisation du système;forme de classe
public Void Draw ()
Console.WriteLine ("Dessin Shape");
Cercle de classe: forme
public void fill ()
Console.WriteLine ("remplissage du cercle");
Square de classe: Forme
Color du public vide ()
Console.WriteLine ("Coloring Square");
programme de classe
statique void main (String [] args)
Circle myCircle = new Circle ();
myircle.Dessiner(); // Sortie: forme de dessin
myircle.Remplir(); // Sortie: cercle de remplissage
Square MySquare = new Square ();
mysquare.Dessiner(); // Sortie: forme de dessin
mysquare.Couleur(); // Sortie: Coloriage carré
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 en forme et peuvent également définir leurs propres méthodes uniques remplies () et couleur ().
Ici, nous avons créé un objet de la classe Circle nommé myircle et un objet du Carré classe nommée mysquare. Nous appelons ensuite le Dessiner() Méthode, qui est héritée de la classe de forme, sur les deux objets.
Ensuite, nous appelons le Remplir() Méthode sur MyCircle, qui est spécifique à la classe Circle, et le Couleur() Méthode sur Mysquare, qui est spécifique à la classe carrée.
La sortie sera imprimée à 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 des interfaces.
Conclusion
L'héritage en C # permet aux classes pour 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é qui est plus facile à entretenir et à étendre.