Héritage C#
Héritage C#
Dans ce tutoriel, nous allons découvrir l'héritage C# et ses types à l'aide d'exemples.
En C#, l'héritage nous permet de créer une nouvelle classe à partir d'une classe existante. C'est une fonctionnalité clé de la programmation orientée objet (POO).
La classe à partir de laquelle une nouvelle classe est créée est appelée classe de base (parent ou superclasse). Et, la nouvelle classe est appelée classe dérivée (enfant ou sous-classe)
La classe dérivée hérite des champs et des méthodes de la classe de base. Cela aide à la réutilisation du code en C#.
Comment effectuer l'héritage en C# ?
En C#, on utilise le : symbole pour effectuer l'héritage. Par exemple,
class Animal {
// fields and methods
}
// Dog inherits from Animal
class Dog : Animal {
// fields and methods of Animal
// fields and methods of Dog
}
Ici, nous héritons de la classe dérivée Dog de la classe de base Animal . Le chien la classe peut maintenant accéder aux champs et aux méthodes de Animal classe.
Exemple :Héritage C#
using System;
namespace Inheritance {
// base class
class Animal {
public string name;
public void display() {
Console.WriteLine("I am an animal");
}
}
// derived class of Animal
class Dog : Animal {
public void getName() {
Console.WriteLine("My name is " + name);
}
}
class Program {
static void Main(string[] args) {
// object of derived class
Dog labrador = new Dog();
// access field and method of base class
labrador.name = "Rohu";
labrador.display();
// access method from own class
labrador.getName();
Console.ReadLine();
}
}
} Sortie
I am an animal My name is Rohu
Dans l'exemple ci-dessus, nous avons dérivé une sous-classe Chien de la superclasse Animal . Remarquez les déclarations,
labrador.name = "Rohu";
labrador.getName(); Ici, nous utilisons labrador (objet de Chien) pour accéder au nom et afficher() de l'Animal classer. Cela est possible car la classe dérivée hérite de tous les champs et méthodes de la classe de base.
De plus, nous avons accédé au name champ à l'intérieur de la méthode du Chien classe.
est-une relation
En C#, l'héritage est une relation is-a. Nous n'utilisons l'héritage que s'il existe une relation is-a entre deux classes. Par exemple,
- Chien est un Animal
- Pomme est un Fruit
- Voiture est un Véhicule
Nous pouvons dériver Chien de Animal classer. De même, Apple à partir de fruits classe et Voiture de Véhicule classe.
Membres protégés dans l'héritage C#
Lorsque nous déclarons un champ ou une méthode comme protected , il n'est accessible qu'à partir de la même classe et de ses classes dérivées.
Exemple :Membres protégés par héritage
using System;
namespace Inheritance {
// base class
class Animal {
protected void eat() {
Console.WriteLine("I can eat");
}
}
// derived class of Animal
class Dog : Animal {
static void Main(string[] args) {
Dog labrador = new Dog();
// access protected method from base class
labrador.eat();
Console.ReadLine();
}
}
} Sortie
I can eat
Dans l'exemple ci-dessus, nous avons créé une classe nommée Animal . La classe inclut une méthode protégée eat() .
Nous avons dérivé le Chien classe de Animal classer. Remarquez la déclaration,
labrador.eat();
Depuis le protected accessible à partir de classes dérivées, nous pouvons accéder à eat() méthode du Chien classe.
Types d'héritage
Il existe les types d'héritage suivants :
1. Héritage unique
En héritage unique, une seule classe dérivée hérite d'une seule classe de base.
2. Héritage à plusieurs niveaux
Dans l'héritage multiniveau, une classe dérivée hérite d'une base, puis la même classe dérivée agit comme une classe de base pour une autre classe.
3. Héritage hiérarchique
Dans l'héritage hiérarchique, plusieurs classes dérivées héritent d'une seule classe de base.
4. Héritage multiple
Dans l'héritage multiple, une seule classe dérivée hérite de plusieurs classes de base. C# ne prend pas en charge l'héritage multiple. Cependant, nous pouvons obtenir un héritage multiple via des interfaces.
5. Héritage hybride
L'héritage hybride est une combinaison de deux ou plusieurs types d'héritage. La combinaison de l'héritage multiniveau et hiérarchique est un exemple d'héritage hybride.
Remplacement de méthode dans l'héritage C#
Si la même méthode est présente à la fois dans la classe de base et dans la classe dérivée, la méthode de la classe dérivée remplace la méthode de la classe de base. C'est ce qu'on appelle le remplacement de méthode en C#. Par exemple,
using System;
namespace Inheritance {
// base class
class Animal {
public virtual void eat() {
Console.WriteLine("I eat food");
}
}
// derived class of Animal
class Dog : Animal {
// overriding method from Animal
public override void eat() {
Console.WriteLine("I eat Dog food");
}
}
class Program {
static void Main(string[] args) {
// object of derived class
Dog labrador = new Dog();
// accesses overridden method
labrador.eat();
}
}
}
Sortie
I eat Dog food
Dans l'exemple ci-dessus, le eat() La méthode est présente à la fois dans la classe de base et dans la classe dérivée.
Lorsque nous appelons eat() en utilisant le chien objet labrador ,
labrador.eat(); la méthode dans Chien est appelé. C'est parce que la méthode à l'intérieur de Dog remplace la même méthode dans Animal .
Remarquez, nous avons utilisé virtual et remplacer avec les méthodes de la classe de base et de la classe dérivée respectivement. Ici,
virtual- permet à la méthode d'être remplacée par la classe dérivéeoverride- indique que la méthode remplace la méthode de la classe de base
mot clé de base dans l'héritage C#
Dans l'exemple précédent, nous avons vu que la méthode de la classe dérivée remplace la méthode de la classe de base.
Cependant, que se passe-t-il si nous voulons également appeler la méthode de la classe de base ?
Dans ce cas, nous utilisons le base mot-clé pour appeler la méthode de la classe de base à partir de la classe dérivée.
Exemple :mot-clé de base dans l'héritage C#
using System;
namespace Inheritance {
// base class
class Animal {
public virtual void eat() {
Console.WriteLine("Animals eat food.");
}
}
// derived class of Animal
class Dog : Animal {
// overriding method from Animal
public override void eat() {
// call method from Animal class
base.eat();
Console.WriteLine("Dogs eat Dog food.");
}
}
class Program {
static void Main(string[] args) {
Dog labrador = new Dog();
labrador.eat();
}
}
} Sortie
Animals eat food. Dogs eat Dog food.
Dans l'exemple ci-dessus, le eat() est présente à la fois dans la classe de base Animal et la classe dérivée Chien . Remarquez la déclaration,
base.eat();
Ici, nous avons utilisé le base mot-clé pour accéder à la méthode de Animal classe du Chien classe.
Importance de l'héritage en C#
Pour comprendre l'importance de l'héritage, considérons une situation.
Supposons que nous travaillions avec des polygones réguliers tels que des carrés, des rectangles, etc. Et, nous devons trouver le périmètre de ces polygones en fonction de l'entrée.
1. Puisque la formule pour calculer le périmètre est commune à tous les polygones réguliers, nous pouvons créer un RegularPolygon classe et une méthode calculatePerimeter() pour calculer le périmètre.
class RegularPolygon {
calculatePerimeter() {
// code to compute perimeter
}
} 2. Et hériter de Carré et Rectangle classes du RegularPolygon classer. Chacune de ces classes aura des propriétés pour stocker la longueur et le nombre de côtés car ils sont différents pour tous les polygones.
class Square : RegularPolygon {
int length = 0;
int sides = 0;
} On passe la valeur de la longueur et côtés à calculateperimeter() pour calculer le périmètre.
C'est ainsi que l'héritage rend notre code réutilisable et plus intuitif.
Exemple :importance de l'héritage
using System;
namespace Inheritance {
class RegularPolygon {
public void calculatePerimeter(int length, int sides) {
int result = length * sides;
Console.WriteLine("Perimeter: " + result);
}
}
class Square : RegularPolygon {
public int length = 200;
public int sides = 4;
public void calculateArea() {
int area = length * length;
Console.WriteLine("Area of Square: " + area);
}
}
class Rectangle : RegularPolygon {
public int length = 100;
public int breadth = 200;
public int sides = 4;
public void calculateArea() {
int area = length * breadth;
Console.WriteLine("Area of Rectangle: " + area);
}
}
class Program {
static void Main(string[] args) {
Square s1 = new Square();
s1.calculateArea();
s1.calculatePerimeter(s1.length, s1.sides);
Rectangle t1 = new Rectangle();
t1.calculateArea();
t1.calculatePerimeter(t1.length, t1.sides);
}
}
} Sortie
Area of Square: 40000 Perimeter: 800 Area of Rectangle: 20000 Perimeter: 400
Dans l'exemple ci-dessus, nous avons créé un RegularPolygon classe qui a une méthode pour calculer le périmètre du polygone régulier.
Ici, le Carré et Rectangle hérite de RegularPolygon .
La formule pour calculer le périmètre est commune à tous, nous avons donc réutilisé le calculatePerimeter() méthode de la classe de base.
Et puisque la formule pour calculer la surface est différente pour différentes formes, nous avons créé une méthode distincte à l'intérieur de la classe dérivée pour calculer la surface.
Langue C