C# 建構函式 (初始化成員變數的角色)

一码事發表於2024-04-05
C#函式變數

建構函式是一種特殊的方法。 建立物件時會自動呼叫它。 建構函式不返回值。 建構函式的目的是初始化物件的狀態。 建構函式與類具有相同的名稱。 建構函式是方法，因此它們也可以過載。

建構函式不能被繼承。 它們按繼承順序被呼叫。 如果我們不為類編寫任何建構函式，則 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
Program.
using System;

namespace Constructor
{
    class Being
    {
        public Being()
        {
            Console.WriteLine("Being is created");
        }

        public Being(string being)
        {
            Console.WriteLine("Being {0} is created", being);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Being();
            new Being("Tom");
        }
    }
}

我們有一個Being類。 此類具有兩個建構函式。 第一個不帶引數； 第二個採用一個引數。

1
2
3
4
public Being(string being)
{
    Console.WriteLine("Being {0} is created", being);
}

此建構函式採用一個字串引數。

new Being();

建立Being類的例項。 這次，在建立物件時呼叫沒有引數的建構函式。

1
2
3
$ dotnet run
Being is created
Being Tom 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
Program.
using System;

namespace Constructor2
{
    class MyFriend
    {
        private DateTime born;
        private string name;

        public MyFriend(string name, DateTime born)
        {
            this.name = name;
            this.born = born;
        }

        public void Info()
        {
            Console.WriteLine("{0} was born on {1}",
                this.name, this.born.ToShortDateString());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var name = "Lenka";
            var born = new DateTime(1990, 3, 5);

            var friend = new MyFriend(name, born);
            friend.Info();
        }
    }
}

我們有一個帶有資料成員和方法的MyFriend類。

1
2
private DateTime born;
private string name;

類定義中有兩個私有變數。

1
2
3
4
5
public MyFriend(string name, DateTime born)
{
    this.name = name;
    this.born = born;
}

在建構函式中，我們啟動兩個資料成員。 this變數是用於引用物件變數的處理程式。

1
2
var friend = new MyFriend(name, born);
friend.Info();

我們建立帶有兩個引數的MyFriend物件。 然後我們呼叫物件的Info()方法。

1
2
$ dotnet run
Lenka was born on 3/5/1990

這是輸出。

C# 建構函式連結

建構函式連結是類從建構函式呼叫另一個建構函式的能力。 要從同一類呼叫另一個建構函式，我們使用this關鍵字。

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
Program.
using System;

namespace ConstructorChaining
{
    class Circle
    {
        public Circle(int radius)
        {
            Console.WriteLine("Circle, r={0} is created", radius);
        }

        public Circle() : this(1)
        {

        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            new Circle(5);
            new Circle();
        }
    }
}

我們有一個Circle類。 該類具有兩個建構函式。 一種採用一個引數，一種不採用任何引數。

1
2
3
4
public Circle(int radius)
{
    Console.WriteLine("Circle, r={0} is created", radius);
}

此建構函式採用一個引數-radius。

1
2
3
4
public Circle() : this(1)
{

}

這是沒有引數的建構函式。 它只是簡單地呼叫另一個建構函式，併為其提供預設半徑 1。

1
2
3
$ dotnet run
Circle, r=5 is created
Circle, r=1 is created

C# ToString方法

每個物件都有一個ToString()方法。 它返回人類可讀的物件表示形式。 預設實現返回Object型別的標準名稱。 請注意，當我們使用物件作為引數呼叫Console.WriteLine()方法時，將呼叫ToString()。

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
Program.
using System;

namespace ToStringMethod
{
    class Being
    {
        public override string ToString()
        {
            return "This is Being class";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var b = new Being();
            var o = new Object();

            Console.WriteLine(o.ToString());
            Console.WriteLine(b.ToString());
            Console.WriteLine(b);
        }
    }
}

我們有一個Being類，其中我們重寫了ToString()方法的預設實現。

1
2
3
4
public override string ToString()
{
    return "This is Being class";
}

建立的每個類都從基object繼承。 ToString()方法屬於此物件類。 我們使用override關鍵字來通知我們正在覆蓋方法。

1
2
var b = new Being();
var o = new Object();

我們建立一個自定義物件和一個內建物件。

1
2
Console.WriteLine(o.ToString());
Console.WriteLine(b.ToString());

我們在這兩個物件上呼叫ToString()方法。

Console.WriteLine(b);

正如我們之前指定的，將物件作為Console.WriteLine()的引數將呼叫其ToString()方法。 這次，我們隱式呼叫了該方法。

1
2
3
4
$ dotnet run
System.Object
This is Being class
This is Being class

這是我們執行示例時得到的。

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
Program.
using System;

namespace ObjectInitializers
{
    class User
    {
        public User() {}

        public string Name { set; get; }
        public string Occupation { set; get; }

        public override string ToString()
        {
            return $"{Name} is a {Occupation}";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var u = new User { Name = "John Doe", Occupation = "gardener" };
            Console.WriteLine(u);
        }
    }
}

在示例中，我們使用物件初始化程式語法建立一個新使用者。

public User() {}

我們定義一個空的建構函式。

1
2
public string Name { set; get; }
public string Occupation { set; get; }

我們有兩個屬性：Name和Occupation。

var u = new User { Name = "John Doe", Occupation = "gardener" };

我們將值分配給{}括號中的屬性。

1
2
$ dotnet run
John Doe is a gardener

C# 類常量

C# 可以建立類常量。 這些常量不屬於具體物件。 他們屬於階級。 按照約定，常量用大寫字母表示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Program.
using System;

namespace ClassConstants
{
    class Math
    {
        public const double PI = 3.14159265359;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Math.PI);
        }
    }
}

我們有一個帶有PI常量的Math類。

public const double PI = 3.14159265359;

const關鍵字用於定義常數。 public關鍵字使它可以在類的主體之外訪問。

1
2
$ dotnet run
3.14159265359

執行示例，我們看到此輸出。

相關文章