English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
L'héritage est l'un des concepts les plus importants de la programmation orientée objet. L'héritage nous permet de définir une autre classe en fonction d'une classe, ce qui rend la création et la maintenance des applications plus faciles. Cela est également avantageux pour la réutilisation du code et l'économie de temps de développement.
Lors de la création d'une classe, le programmeur n'a pas besoin de réécrire complètement les nouveaux membres de données et les fonctions membres, il suffit de concevoir une nouvelle classe, qui hérite des membres d'une classe existante. Cette classe existante est appeléeClasse de base， cette nouvelle classe est appelée派生类.
L'idée d'héritage a été mise en œuvre Appartient à (IS-A) Relation. Par exemple, Mammifère Appartient à (IS-A) Animal, chien Appartient à (IS-A) Mammifère, donc le chien Appartient à (IS-A) Animal.
Une classe peut hériter de plusieurs classes ou interfaces, ce qui signifie qu'elle peut hériter de données et de fonctions de plusieurs classes ou interfaces de base.
La syntaxe pour créer une classe dérivée en C# est la suivante :
<modificateur d'accès> class <基类>
{
...
}
class <派生类> : <基类>
{
...
}
Supposons qu'il y ait une classe de base Shape, dont la classe dérivée est Rectangle :
using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
// 派生类
class Rectangle: Shape
{
public int getArea()
{
return (width * height);
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
45);
47);
//
440;));
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
Surface totale : 35
Les classes dérivées héritent des variables membres et des méthodes des classes de base. Par conséquent, l'objet de la classe parent doit être créé avant l'objet de la classe enfant. Vous pouvez initialiser la classe parent dans la liste d'initialisation des membres.
Le programme suivant illustre cela :
using System;
namespace RectangleApplication
{
class Rectangle
{
// variables membres
protected double length;
protected double width;
public Rectangle(double l, double w)
{
length = l;
width = w;
}
public double GetArea()
{
return length * width;
}
public void Display()
{
40;"longueur: {0}", length);
40;"largeur: {0}", width);
40;"surface: {0}", GetArea());
}
}//end class Rectangle
class Tabletop : Rectangle
{
private double cost;
public Tabletop(double l, double w) : base(l, w)
{ }
public double GetCost()
{
double cost;
cost = GetArea() * 7
return cost;
}
public void Display()
{
base.Display();
40;"成本： {0}", GetCost());
}
}
class ExecuteRectangle
{
static void Main(string[] args)
{
Tabletop t = new Tabletop,.5, 7.5);
t.Display();
Console.ReadLine();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
长度： 4.5 宽度： 7.5 面积： 33.75 成本： 2362.5
多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。
C# 不支持多重继承。但是，您可以使用接口来实现多重继承。下面的程序演示了这点：
using System;
namespace InheritanceApplication
{
class Shape
{
public void setWidth(int w)
{
width = w;
}
public void setHeight(int h)
{
height = h;
}
protected int width;
protected int height;
}
// 基类 PaintCost
public interface PaintCost
{
int getCost(int area);
}
// 派生类
class Rectangle : Shape, PaintCost
{
public int getArea()
{
return (width * height);
}
public int getCost(int area)
{
return area * 7
}
}
class RectangleTester
{
static void Main(string[] args)
{
Rectangle Rect = new Rectangle();
int area;
45);
47);
40;);
//
440;));
40;\40;area));
Console.ReadKey();
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
Surface totale : 35 Coût total de la peinture : $2450