上查看所有课程
在 C# 中，构造函数类似于在创建类对象时被调用的方法。
然而，与方法不同的是，构造函数
- 具有与类相同的名称
- 没有返回类型
创建 C# 构造函数
我们在 C# 中创建构造函数的方法如下：
class Car {
// constructor
Car() {
//code
}
}这里，Car() 是一个构造函数。它的名称与它的类相同。
调用构造函数
创建构造函数后，我们可以使用 new 关键字调用它。例如，
new Car();在 C# 中，当我们尝试创建类的对象时，会调用构造函数。例如，
Car car1 = new Car();在这里，我们调用 Car() 构造函数来创建一个对象 car1。要了解更多关于对象的信息，请访问 C# 类和对象。
构造函数类型
有以下类型的构造函数：
- 无参构造函数
- 带参构造函数
- 默认构造函数
1. 无参构造函数
当我们创建一个不带参数的构造函数时，它被称为无参构造函数。例如，
using System;
namespace Constructor {
class Car {
// parameterless constructor
Car() {
Console.WriteLine("Car Constructor");
}
static void Main(string[] args) {
// call constructor
new Car();
Console.ReadLine();
}
}
}输出
Car Constructor
在上面的示例中，我们创建了一个名为 Car() 的构造函数。
new Car();我们可以通过在构造函数名称前添加 new 关键字来调用构造函数。
2. C# 带参构造函数
在 C# 中，构造函数也可以接受参数。它被称为带参构造函数。例如，
using System;
namespace Constructor {
class Car {
string brand;
int price;
// parameterized constructor
Car(string theBrand, int thePrice) {
brand = theBrand;
price = thePrice;
}
static void Main(string[] args) {
// call parameterized constructor
Car car1 = new Car("Bugatti", 50000);
Console.WriteLine("Brand: " + car1.brand);
Console.WriteLine("Price: " + car1.price);
Console.ReadLine();
}
}
}输出
Brand: Bugatti Price: 50000
在上面的示例中，我们创建了一个名为 Car() 的构造函数。该构造函数接受两个参数：theBrand 和 thePrice。
请注意以下语句：
Car car1 = new Car("Bugatti", 50000);在这里，我们将两个值传递给构造函数。
传递给构造函数的值称为参数。我们必须传递与参数相同数量和类型的值。
3. 默认构造函数
如果我们在类中没有定义构造函数，那么 C# 将自动创建一个没有代码和参数的默认构造函数。例如，
using System;
namespace Constructor {
class Program {
int a;
static void Main(string[] args) {
// call default constructor
Program p1 = new Program();
Console.WriteLine("Default value of a: " + p1.a);
Console.ReadLine();
}
}
}输出
Default value of a: 0
在上面的示例中，我们在 Program 类中没有创建任何构造函数。但是，在创建对象时，我们正在调用构造函数。
Program p1 = new Program();
在这里，C# 自动创建了一个默认构造函数。默认构造函数会将任何未初始化的变量初始化为默认值。
因此，我们得到 int 变量 a 的值为 0。
注意：在默认构造函数中，所有数值字段都初始化为 0，而字符串和对象初始化为 null。
4. C# 中的复制构造函数
我们使用复制构造函数通过复制另一个对象的数据来创建对象。例如，
using System;
namespace Constructor {
class Car {
string brand;
// constructor
Car (string theBrand) {
brand = theBrand;
}
// copy constructor
Car(Car c1) {
brand = c1.brand;
}
static void Main(string[] args) {
// call constructor
Car car1 = new Car("Bugatti");
Console.WriteLine("Brand of car1: " + car1.brand);
// call the copy constructor
Car car2 = new Car(car1);
Console.WriteLine("Brand of car2: " + car2.brand);
Console.ReadLine();
}
}
}输出
Brand of car1: Bugatti Brand of car2: Bugatti
在上面的程序中，我们使用了复制构造函数。
Car(Car c1) {
brand = c1.brand;
}这里，这个构造函数接受一个 Car 对象作为参数。因此，在创建 car2 对象时，我们将 car1 对象作为参数传递给复制构造函数。
Car car2 = new Car(car1);在复制构造函数内部，我们将 car1 对象的 brand 值赋给了 car2 对象的 brand 变量。因此，两个对象具有相同的 brand 值。
5. 私有构造函数
我们可以使用 private 访问修饰符创建私有构造函数。这被称为 C# 中的私有构造函数。
一旦将构造函数声明为私有，我们就不能在其他类中创建该类的对象。
示例 1：私有构造函数
using System;
namespace Constructor {
class Car {
// private constructor
private Car () {
Console.WriteLine("Private Constructor");
}
}
class CarDrive {
static void Main(string[] args) {
// call private constructor
Car car1 = new Car();
Console.ReadLine();
}
}
}在上面的示例中，我们创建了一个私有构造函数 Car()。由于私有成员不能在类外部访问，因此当我们尝试创建 Car 的对象时，
// inside CarDrive class
Car car1 = new Car();我们会收到一个错误。
error CS0122: 'Car.Car()' is inaccessible due to its protection level注意：如果构造函数是私有的，我们不能创建类的对象。因此，类中的所有字段和方法都应声明为静态，以便可以通过类名访问它们。
6. C# 静态构造函数
在 C# 中，我们也可以将构造函数设为静态。我们使用 static 关键字创建静态构造函数。例如，
using System;
namespace Constructor {
class Car {
// static constructor
static Car () {
Console.WriteLine("Static Constructor");
}
// parameterless constructor
Car() {
Console.WriteLine("Default Constructor");
}
static void Main(string[] args) {
// call parameterless constructor
Car car1 = new Car();
// call parameterless constructor again
Car car2 = new Car();
Console.ReadLine();
}
}
}在上面的示例中，我们创建了一个静态构造函数。
static Car () {
Console.WriteLine("Static Constructor");
}我们不能直接调用静态构造函数。但是，当我们调用常规构造函数时，静态构造函数会自动被调用。
Car car1 = new Car();在这里，我们调用 Car() 构造函数。您可以看到静态构造函数也与常规构造函数一起被调用。
输出
Static Constructor Default Constructor Default Constructor
静态构造函数在程序执行期间只调用一次。这就是为什么当我们再次调用构造函数时，只调用常规构造函数。
注意：一个类只能有一个静态构造函数。它不能有任何参数或访问修饰符。
C# 构造函数重载
在 C# 中，我们可以在类中创建两个或多个构造函数。这被称为构造函数重载。例如，
using System;
namespace ConstructorOverload {
class Car {
// constructor with no parameter
Car() {
Console.WriteLine("Car constructor");
}
// constructor with one parameter
Car(string brand) {
Console.WriteLine("Car constructor with one parameter");
Console.WriteLine("Brand: " + brand);
}
static void Main(string[] args) {
// call constructor with no parameter
Car car = new Car();
Console.WriteLine();
// call constructor with parameter
Car car2 = new Car("Bugatti");
Console.ReadLine();
}
}
}输出
Car constructor Car constructor with one parameter Brand: Bugatti
在上面的示例中，我们重载了 Car 构造函数。
- 一个构造函数带一个参数。
- 另一个带两个参数。
根据构造函数调用期间传递的参数数量，将调用相应的构造函数。
这里，
- 对象 car - 调用带一个参数的构造函数
- 对象 car2 - 调用带两个参数的构造函数
要了解更多，请访问 C# 构造函数重载。