C# 繼承

一码事發表於2024-04-05
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

這是示例的輸出。

相關文章