跳到主要内容

C# 构造函数重载

提示
  1. 构造函数重载的基础：在 C# 中，构造函数可以重载，这意味着一个类可以有多个构造函数，它们的参数数量、类型或顺序不同。
  2. 参数数量和类型的变化：重载构造函数可以通过改变参数的数量或类型实现，例如，一个构造函数没有参数，而另一个可能有一个或多个参数，或参数的数据类型不同。
  3. 参数顺序的重要性：当构造函数的参数数量相同但顺序不同时，也可以实现重载，这允许更灵活地初始化对象。

在 C# 中，类似于方法重载，我们也可以重载构造函数。对于构造函数重载，必须有两个或更多具有相同名称但参数不同的构造函数，包括：

  • 参数的数量
  • 参数的类型
  • 参数的顺序

在学习构造函数重载之前，确保了解了 C# 构造函数。

我们可以通过以下方式执行构造函数重载：

1. 参数数量不同​

如果构造函数中的参数数量不同，我们可以重载构造函数。

 class Car {

  Car() {
    ...
  }

  Car(string brand) {
    ...
  }

  Car(string brand, int price) {
    ...
  }

}

这里，我们在 Car 类中有三个构造函数。由于构造函数中的参数数量不同，因此可以有多个构造函数。

注意，

  • Car() { } - 没有参数
  • Car(string brand) { } - 有一个参数
  • Car(string brand, int price) { } - 有两个参数

示例：参数数量不同的构造函数重载​

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 构造函数：

  1. 一个构造函数有一个参数
  2. 另一个有两个参数

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

这里，

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

2. 参数类型不同​

class Car {

  Car(string brand) {
    ...
   }

  Car(int price) {
    ...
  }
}

这里，我们有两个 Car 构造函数，参数数量相同。我们能够创建参数数量相同的构造函数，因为参数内的数据类型不同。

注意，

  • Car(string brand) { } - 参数类型为 string
  • Car(int price) { } - 参数类型为 int

示例：参数类型不同的构造函数重载​

using System;

namespace ConstructorOverload {

  class Car {

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

    // 带 int 参数的构造函数
    Car(int price) {
      Console.WriteLine("价格: " + price);
    }

    static void Main(string[] args) {

      // 调用带 string 参数的构造函数
      Car car = new Car("Lamborghini");

      Console.WriteLine();

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

      Console.ReadLine();
    }
  }
}

输出

品牌: Lamborghini

价格: 50000

在上述程序中，我们通过不同类型的参数重载了构造函数。

这里，

  1. 对象 car - 调用带 string 类型参数的构造函数
  2. 对象 car2 - 调用带 int 类型参数的构造函数

3. 参数顺序不同​

Car {

  Car(string brand, int price) {
    ...
  }

  Car(int speed, string color) {
    ...
  }

}

这里，我们有两个构造函数，参数数量相同。这是可能的，因为参数中数据类型的顺序不同。

注意，

  • Car(string brand, int price) { } - string 数据类型在 int 之前
  • Car(int speed, string color) { } - int 数据类型在 string 之前

示例：参数顺序不同的构造函数重载​

using System;

namespace ConstructorOverload {

  class Car {

    // 带 string 和 int 参数的构造函数
    Car(string brand, int price) {

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

    // 带 int 和 string 参数的构造函数
    Car(int speed, string color) {

      Console.WriteLine("速度: " + speed + " km/hr");
      Console.WriteLine("颜色: " + color);
    }
    static void Main(string[] args) {

      // 调用带 string 和 int 参数的构造函数
      Car car = new Car("Bugatti", 50000);

      Console.WriteLine();

      // 调用带 int 和 string 参数的构造函数
      Car car2 = new Car(60, "红色");

      Console.ReadLine();
    }
  }
}

输出

品牌: Bugatti
价格: 50000

速度: 60 km/hr
颜色: 红色

在上述程序中，我们通过不同顺序的参数重载了构造函数。

这里，

  1. 对象 car - 分别调用带 string 和 int 参数的构造函数
  2. 对象 car2 - 分别调用带 int 和 string 参数的构造函数
最后于 更新