C# 构造函数

C# 构造函数是一种在类中定义的用于初始化该类变量的方法。通常，构造函数的名称应与类名相同。构造函数不返回任何值，因此它被称为不返回值的方法。

通常，每个类都包含一些字段或变量。执行该类所需的值通过构造函数传递给它。C# 构造函数的语法如下所示。

[<Access specifier>] <ConstructorName>([<parameter list>])
{
   Statements;
}

正如我们已经说过的，对象将创建以访问类的字段和成员函数。相比之下，C# 构造函数对于创建类的实例或对象很有用。

程序员必须在类中显式定义构造函数。否则，在执行时，编译器会默认创建一个构造函数。我们称之为隐式或默认构造函数。

C# 构造函数可以是静态的或非静态的。除了使用访问修饰符 `static` 定义的构造函数外，所有构造函数都是非静态的。让我们看看当类中没有定义构造函数时，默认构造函数如何调用来初始化变量。

using System;

namespace CSharp_Tutorial
{
    class Program
    {
        int a;
        bool b;
        static void Main(string[] args)
        {
            Program p = new Program();
            Console.WriteLine("value of integer a is: " + p.a);
            Console.WriteLine("value of boolean b is: " + p.b);
            Console.ReadLine();
        }
    }
}
C# Constructor 1

在上面的示例程序中，a 是一个整数变量，b 是一个布尔变量。这里，我们没有定义构造函数来初始化这些变量，但要求打印它们的值。

在执行时，编译器会创建一个隐式构造函数来初始化变量 a、b，并打印默认值。即，整数变量 a 的值为 0，布尔变量 b 的值为 false。

注意：即使类中没有定义构造函数。当我们尝试调用它时，编译器将默认调用无参数构造函数。因此，由编译器调用且未显式定义的构造函数称为隐式构造函数。

C# 中的构造函数类型

以下是这种编程语言中不同类型的构造函数。

  • 默认或无参数。
  • 带参数
  • 复制。
  • 静态。

C# 中的默认无参数构造函数

任何不带任何值（或）不带任何参数的方法都将调用无参数或默认构造函数。

C# 默认或无参数构造函数的语法。

using System;

public Class_name ()
{
       --statements--
}

让我们看一个与之前执行的示例程序相同的程序，只是稍微修改了一下，显式定义了构造函数。

using System;

namespace CSharp_Tutorial
{
    class Program
    {
        int a;
        bool b;
        public Program()
        {
            Console.WriteLine("Parameterless constructor is called");
        }
        static void Main(string[] args)
        {
            Program p = new Program();
            Console.WriteLine("value of integer a is: " + p.a);
            Console.WriteLine("value of boolean b is: " + p.b);
            Console.ReadLine();
        }
    }
}
Default Constructor

在执行时，编译器将调用我们显式定义的无参数构造函数。

Program() 是我们显式创建的无参数构造函数。通过它，我们创建了一个对象 p 并尝试打印整数变量 a 和布尔变量 b 的值。由于我们没有初始化这些变量，编译器会打印默认值并将其赋值给整数和布尔变量。

C# 带参数构造函数

带有参数（或）接受值的构造函数称为带参数构造函数。程序员应显式定义带参数构造函数。

带参数构造函数的语法是

public Class_name (<parameter_list>)
{
       --statements--
}

让我们看一个带参数构造函数的例子

using System;


namespace CSharp_Tutorial
{
    class Program
    {
        int x;
        public Program(int i)
        {
            x = i;
            Console.WriteLine("Parameterized constructor is called");
        }
        void Print()
        {
            Console.WriteLine("Value of x is:" + x);
        }


        static void Main(string[] args)
        {
            Program p1 = new Program(500);
            p1.Print();
            Console.ReadLine();
        }
    }
}
Parameterized Constructor

这里，Program (int i) 是一个带参数的构造函数，用参数 i（一个整数变量）创建。接下来，全局变量 x（整数类型）用 i 初始化。通过使用这个构造函数，在将参数 500 传递给参数 i 时创建了一个对象 p1。

当我们尝试调用 Print() 方法时，它通过将参数 500 传递给 x 来执行方法中的语句，因为 x 已用 i 初始化。

C# 复制构造函数

将一个对象的数据复制到另一个对象的构造函数称为复制构造函数。我们使用复制构造函数创建具有相同值的多个对象。

复制构造函数是带参数的，它将同一个类作为参数。复制构造函数的语法是

public class_name(class_name <instance of a class>)
{
     --Statements--
}

以下示例向您展示了如何编写复制构造函数程序

using System;


namespace CSharp_Tutorial
{
    class Program
    {
        int a;
        bool b;
        public Program()
        {
            Console.WriteLine("Parameterless constructor is called");
        }
        static void Main(string[] args)
        {
            Program p = new Program();
            Console.WriteLine("value of integer a is: " + p.a);
            Console.WriteLine("value of boolean b is: " + p.b);
            Console.ReadLine();
        }
    }
}
Copy Constructor Example

copycon_Program 是 C# 类名。这里，复制构造函数创建时带有一个参数 obj 作为实例

P2 是将在复制构造函数的帮助下创建的实例。为此，带参数构造函数的实例，即 p1 作为参数传递。

由于对象 p1 作为参数传递给对象 p2，因此对象 p1 中的数据将复制到 p2 并打印相同的值。

C# 静态构造函数

使用访问修饰符 `static` 定义的构造函数是静态构造函数。我们到目前为止讨论的都是非静态构造函数。

正如我们已经看到的，当我们在类中没有定义任何构造函数时，非静态构造函数会隐式调用。然而，对于静态构造函数，如果类包含任何静态变量，那么编译器将调用隐式静态构造函数。否则，我们需要显式定义静态构造函数。静态构造函数的语法如下所示。

static class_name()
{
   --statements—
}

让我们看一个静态构造函数的例子

using System;


namespace CSharp_Tutorial
{
    class static_Program
    {
        int x;
        static static_Program()
        {
            Console.WriteLine("static Constructor is called");


        }
        static void Main(string[] args)
        {


            Console.WriteLine("Main method is called");
            Console.ReadLine();
        }
    }
}
Static constructors

当我们执行程序时，由于静态构造函数是第一个运行的，编译器首先执行静态构造函数。然后它进入主方法执行其中的代码。

C# 静态与非静态构造函数

静态非静态
静态构造函数用于初始化静态变量。非静态构造函数用于初始化非静态变量。
这些不会被显式调用，因为静态构造函数是每个类中第一个执行的代码块。这些构造函数在类执行开始时立即执行，并且在类的生命周期中只执行一次。但是对于非静态构造函数，如果没有创建实例，它们根本不会执行。但是如果创建了 n 个实例，它们将执行 n 次。
静态构造函数不能带参数，因为它不能接受参数，因为它是第一个执行的代码块。因此，这些构造函数不能重载。它们可以带参数，因此可以重载。

C# 中显式构造函数的实际需求是什么？

即使我们没有显式定义它，编译器也会调用隐式构造函数来创建类的实例。然而，当我们创建多个类实例时，类的变量将用相同的值初始化。这是因为在此编程语言中，隐式构造函数始终是无参数的。

因此，如果我们希望通过创建多个实例来为类的变量分配不同的值，则必须显式定义带参数的构造函数。

最后，我们可以说，如果我们的类变量需要一些值来执行，那么应该定义显式构造函数以传递多个值。因此，每次创建新对象时，我们都有机会传递新值。

using System;

namespace ConsoleApp2
{
  class Program2
  {
   public int i = 50;
  } 
}
namespace ConsoleApp2
{
  class Program
  {
    public int x;
    public Program(int a)
    {
      this.x = a;
    }
  }
}
namespace ConsoleApp2
{
  class Test
  {  
    static void Main()
    {
      Program p = new Program(1000);
      Program p1 = new Program(2000);
      Program p2 = new Program(6000);
      Console.WriteLine(p.x + " " + p1.x + " " + p2.x);
      Program2 r = new Program2();
      Program2 r1 = new Program2();
      Program2 r2 = new Program2();
      Console.WriteLine(r.i + " " + r1.i + " " + r2.i);
      Console.ReadLine();
    }
  }
}
Explicit Example

在上面的示例构造函数程序中，在单个命名空间 ConsoleApp2 下创建了三个类，

第一个是 Program2 类，第二个是 Program 类，第三个是 Test 类。主方法将写在 Test 类中。

在 program2 中，整数变量 i 用 50 初始化，并在 Test 类中创建了三个实例 r、r1 和 r2。

由于它没有任何构造函数，编译器会调用默认构造函数来创建实例 r、r1 和 r2。当我们尝试将 i 值写入控制台时，每次都会打印相同的 i 值，即 50，因为 C# 隐式构造函数是无参数的。它不能接受任何参数来改变值。

Program 类是使用其中定义的带参数的 Program (int a) 创建的。

因此，对于每个新创建的实例，构造函数将接受不同的整数值（即 1000、2000、6000）。因为有一个整数变量作为参数。

分类 C#