C# 构造函数

在本教程中，我们将通过示例了解 C# 构造函数及其类型。

在 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 和 价格 .

注意声明，

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# 会自动创建一个默认构造函数。默认构造函数使用默认值初始化任何未初始化的变量。

因此，我们得到 0 作为 int 的值变量 a .

注意 :在默认构造函数中，所有数值字段都初始化为0，而string和object初始化为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);

在复制构造函数中，我们已经分配了 brand 的值对于 car1 反对品牌 car2 的变量目的。因此，两个对象都具有相同的 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 构造函数：

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

根据构造函数调用时传入的参数个数，调用对应的构造函数。

在这里，

对象汽车 - 使用一个参数调用构造函数
对象 car2 - 使用两个参数调用构造函数

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

C# 变量范围 C#这个关键字

C语言