跳到主要内容

C# 构造函数

提示
  1. 构造函数的基本概念：构造函数是类名相同且没有返回类型的特殊方法，它在创建类的对象时自动调用。
  2. 构造函数的类型：C# 支持多种类型的构造函数，包括无参构造函数、带参构造函数、默认构造函数、拷贝构造函数、私有构造函数和静态构造函数。
  3. 构造函数重载：在 C# 中，可以根据参数的不同重载构造函数，提供不同方式的对象初始化。

在 C# 中，构造函数类似于当类的对象被创建时调用的方法。

然而，与方法不同的是，构造函数：

  • 与类名相同
  • 没有任何返回类型

创建 C# 构造函数​

下面是在 C# 中创建构造函数的方法：

class Car {

  // 构造函数
  Car() {
    // 代码
  }

}

这里，Car() 是一个构造函数。它与其类名相同。

调用构造函数

一旦我们创建了构造函数，就可以使用 new 关键字来调用它。例如，

new Car();

在 C# 中，当我们尝试创建类的对象时，会调用构造函数。例如，

Car car1 = new Car();

这里，我们调用 Car() 构造函数来创建对象 car1。要了解更多关于对象的信息，请访问 C# 类和对象。

构造函数类型​

有以下几种类型的构造函数：

  • 无参构造函数
  • 带参构造函数
  • 默认构造函数

1. 无参构造函数​

当我们创建没有参数的构造函数时，称为无参构造函数。例如，

using System;

namespace Constructor {

  class Car {

    // 无参构造函数
    Car() {
      Console.WriteLine("Car 构造函数");
    }

    static void Main(string[] args) {

      // 调用构造函数
      new Car();
      Console.ReadLine();

    }
  }
}

输出

Car 构造函数

在上述示例中，我们创建了名为 Car() 的构造函数。

new Car();

我们可以通过在构造函数名称前添加 new 关键字来调用构造函数。

2. C# 带参构造函数​

在 C# 中，构造函数也可以接受参数。这被称为带参构造函数。例如，

using System;

namespace Constructor {

  class Car {

    string brand;
    int price;

    // 带参构造函数
    Car(string theBrand, int thePrice) {

      brand = theBrand;
      price = thePrice;
    }

    static void Main(string[] args) {

      // 调用带参构造函数
      Car car1 = new Car("Bugatti", 50000);

      Console.WriteLine("品牌: " + car1.brand);
      Console.WriteLine("价格: " + car1.price);
      Console.ReadLine();

    }
  }
}

输出

品牌: Bugatti
价格: 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) {

      // 调用默认构造函数
      Program p1 = new Program();

      Console.WriteLine("a 的默认值: " + p1.a);
      Console.ReadLine();

    }
  }
}

输出

a 的默认值: 0

在上述示例中，我们没有在 Program 类中创建任何构造函数。然而，在创建对象时，我们正在调用构造函数。

Program p1 = new Program();

这里，C# 自动创建了一个默认构造函数。默认构造函数会将任何未初始化的变量初始化为默认值。

因此，我们得到 int 变量 a 的值 0。

注意：在默认构造函数中，所有数值字段初始化为 0，而字符串和对象初始化为 null。

4. C# 中的拷贝构造函数​

我们使用拷贝构造函数通过从另一个对象复制数据来创建对象。例如，

using System;

namespace Constructor {

  class Car {
    string brand;

    // 构造函数
    Car (string theBrand) {
      brand = theBrand;
    }

    // 拷贝构造函数
    Car(Car c1) {
      brand = c1.brand;
    }

    static void Main(string[] args) {
      // 调用构造函数
      Car car1 = new Car("Bugatti");

      Console.WriteLine("car1 的品牌: " + car1.brand);

      // 调用拷贝构造函数
      Car car2 = new Car(car1);
      Console.WriteLine("car2 的品牌: " + car2.brand);

      Console.ReadLine();

    }
  }
}

输出

car1 的品牌: Bugatti
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 Car () {
    Console.WriteLine("私有构造函数");
    }
  }

    class CarDrive {

      static void Main(string[] args) {

      // 调用私有构造函数
      Car car1 = new Car();
      Console.ReadLine();
    }
  }
}

在上面的示例中，我们创建了一个私有构造函数 Car()。由于私有成员不能在类的外部访问，当我们尝试创建 Car 的对象时

// 在 CarDrive 类内部
Car car1 = new Car();

我们会遇到一个错误

error CS0122: 'Car.Car()' 由于其保护级别而无法访问

注意：如果构造函数是私有的，我们就不能创建该类的对象。因此，该类的所有字段和方法都应该声明为静态，这样它们就可以使用类名来访问。

6. C# 静态构造函数​

在 C# 中，我们也可以将构造函数设为静态。我们使用 static 关键字来创建静态构造函数。例如，

using System;

namespace Constructor {

  class Car {

   // 静态构造函数
   static Car () {
    Console.WriteLine("静态构造函数");
   }

    // 无参构造函数
    Car() {
     Console.WriteLine("默认构造函数");
   }

    static void Main(string[] args) {

      // 调用无参构造函数
      Car car1 = new Car();

      // 再次调用无参构造函数
      Car car2 = new Car();

      Console.ReadLine();
    }
  }
}

在上面的示例中，我们创建了一个静态构造函数。

static Car () {
  Console.WriteLine("静态构造函数");
}

我们不能直接调用静态构造函数。然而，当我们调用普通构造函数时，静态构造函数会自动被调用。

Car car1 = new Car();

这里，我们调用的是 Car() 构造函数。你可以看到静态构造函数也与普通构造函数一起被调用。

输出

静态构造函数
默认构造函数
默认构造函数

静态构造函数在程序执行期间只被调用一次。这就是为什么当我们再次调用构造函数时，只有普通构造函数被调用。

注意：我们在一个类中只能有一个静态构造函数。它不能有任何参数或访问修饰符。

C# 构造函数重载​

在 C# 中，我们可以在一个类中创建两个或更多的构造函数。这被称为构造函数重载。例如，

using System;

namespace ConstructorOverload {

  class Car {

    // 无参数的构造函数
    Car() {
      Console.WriteLine("Car 构造函数");
    }

    // 带一个参数的构造函数
    Car(string brand) {
      Console.WriteLine("带一个参数的 Car 构造函数");
      Console.WriteLine("品牌: " + brand);
    }

    static void Main(string[] args) {

      // 调用无参数的构造函数
      Car car = new Car();

      Console.WriteLine();

      // 调用带参数的构造函数
      Car car2 =  new Car("Bugatti");

      Console.ReadLine();
    }
  }
}

输出

Car 构造函数

带一个参数的 Car 构造函数
品牌: Bugatti

在上述示例中，我们重载了 Car 构造函数：

  • 一个构造函数有一个参数
  • 另一个构造函数有两个参数

根据在构造函数调用期间传递的参数数量，相应的构造函数被调用。

这里，

  • 对象 car - 调用带一个参数的构造函数
  • 对象 car2 - 调用带两个参数的构造函数

要了解更多信息，请访问 C# 构造函数重载。

最后于 更新