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

运行示例，我们看到此输出。