C# 继承
继承是使用已经定义的类形成新类的方法。 新形成的类称为派生的类，我们派生的类称为基类。 继承的重要好处是代码重用和降低程序的复杂性。 派生类（后代）将覆盖或扩展基类（祖先）的功能。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Program.
using System;
namespace Inheritance
{
class Being
{
public Being()
{
Console.WriteLine("Being is created");
}
}
class Human : Being
{
public Human()
{
Console.WriteLine("Human is created");
}
}
class Program
{
static void Main(string[] args)
{
new Human();
}
}
}
在此程序中，我们有两个类。 基类Being和派生的Human类。 派生类继承自基类。
class Human : Being
在 C# 中，我们使用冒号（:)运算符创建继承关系。
new Human();
我们实例化派生的Human类。
1
2
3
$ dotnet run
Being is created
Human is created
我们可以看到两个构造函数都被调用了。 首先，调用基类的构造函数，然后调用派生类的构造函数。
接下来是一个更复杂的示例。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
Program.
using System;
namespace Inheritance2
{
class Being
{
static int count = 0;
public Being()
{
count++;
Console.WriteLine("Being is created");
}
public void GetCount()
{
Console.WriteLine("There are {0} Beings", count);
}
}
class Human : Being
{
public Human()
{
Console.WriteLine("Human is created");
}
}
class Animal : Being
{
public Animal()
{
Console.WriteLine("Animal is created");
}
}
class Dog : Animal
{
public Dog()
{
Console.WriteLine("Dog is created");
}
}
class Program
{
static void Main(string[] args)
{
new Human();
var dog = new Dog();
dog.GetCount();
}
}
}
我们有四个班。 继承层次更加复杂。 Human和Animal类继承自Being类。 Dog 类直接继承自Animal类，并间接继承自Being类。 我们还介绍了static变量的概念。
static int count = 0;
我们定义一个static变量。 静态成员是类的所有实例共享的成员。
1
2
3
4
5
Being()
{
count++;
Console.WriteLine("Being is created");
}
每次实例化Being类时，我们将 count 变量增加一。 这样，我们就可以跟踪创建的实例数。
1
2
3
4
5
class Animal : Being
...
class Dog : Animal
...
Animal继承自Being，Dog继承自Animal。 Dog也间接继承自Being。
1
2
3
new Human();
var dog = new Dog();
dog.GetCount();
我们从Human和Dog类创建实例。 我们称为 Dog 对象的GetCount()方法。
1
2
3
4
5
6
7
$ dotnet run
Being is created
Human is created
Being is created
Animal is created
Dog is created
There are 2 Beings
Human调用两个构造函数。 Dog调用三个构造函数。 有两个实例化的存在。
我们使用base关键字显式调用父级的构造函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
Program.
using System;
namespace Shapes
{
class Shape
{
protected int x;
protected int y;
public Shape()
{
Console.WriteLine("Shape is created");
}
public Shape(int x, int y)
{
this.x = x;
this.y = y;
}
}
class Circle : Shape
{
private int r;
public Circle(int r, int x, int y) : base(x, y)
{
this.r = r;
}
public override string ToString()
{
return String.Format("Circle, r:{0}, x:{1}, y:{2}", r, x, y);
}
}
class Program
{
static void Main(string[] args)
{
var c = new Circle(2, 5, 6);
Console.WriteLine(c);
}
}
}
我们有两个类：Shape类和Circle类。 Shape类是几何形状的基类。 我们可以在此类中加入一些常见形状的共同点，例如x和y坐标。
1
2
3
4
5
6
7
8
9
10
public Shape()
{
Console.WriteLine("Shape is created");
}
public Shape(int x, int y)
{
this.x = x;
this.y = y;
}
Shape类具有两个构造函数。 第一个是默认构造函数。 第二个参数有两个参数：x，y 坐标。
1
2
3
4
public Circle(int r, int x, int y) : base(x, y)
{
this.r = r;
}
这是Circle类的构造函数。 此构造函数启动r成员并调用父级的第二个构造函数，并向其传递x和y坐标。 如果不使用base关键字显式调用构造函数，则将调用Shape类的默认构造函数。
1
2
$ dotnet run
Circle, r:2, x:5, y:6
这是示例的输出。
