C#基础—构造函数

转载自微软相关官方文档；

https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/classes-and-structs/using-constructors

每当创建类或结构时，将会调用其构造函数。 类或结构可能具有采用不同参数的多个构造函数。 使用构造函数，程序员能够设置默认值、限制实例化，并编写灵活易读的代码。

构造函数与该类或结构具有相同名称，并且通常初始化新对象的数据成员。 其方法签名仅包含方法名称和其参数列表；它不包含返回类型。

public class Person
{
   private string last;
   private string first;
   
   public Person(string lastName, string firstName)
   {
      last = lastName;
      first = firstName;
   }
   
   // Remaining implementation of Person class.
}

or

public class Location
{
   private string locationName;
   
   public Location(string name) => locationName = name;

   public string Name
   {
      get => locationName;
      set => locationName = value;
   } 
}

使用构造函数

通过使用简单构造函数定义了一个名为 Taxi 的类。 然后使用 new 运算符对该类进行实例化。 在为新对象分配内存之后，new 运算符立即调用 Taxi 构造函数。

public class Taxi
{
    public bool isInitialized;
    public Taxi()
    {
        isInitialized = true;
    }
}

class TestTaxi
{
    static void Main()
    {
        Taxi t = new Taxi();
        Console.WriteLine(t.isInitialized);
    }
}

s

1.通过将构造函数设置为私有构造函数，可以阻止类被实例化——class NLog { private NLog() { } }

   构造函数可以将标记为公共，私有，保护，内部，受保护内部或私有受保护。 这些访问修饰符定义类的用户构造该类的方式。

2.结构类型的构造函数与类的构造函数类似，但是 structs 不能包含显式默认构造函数，因为编译器将自动提供一个显式默认构造函数。

3.类和 structs 都可以定义带参数的构造函数。 必须通过 new 语句或 base 语句调用带参数的构造函数。 类和 structs 还可以定义多个构造函数，并且二者均不需要定义默认构造函数。

4.构造函数可以使用 this 关键字调用同一对象中的另一构造函数。 和 base 一样，this 可带参数使用也可不带参数使用，构造函数中的任何参数都可用作 this 的参数，或者用作表达式的一部分。

    在执行构造函数块之前调用基类的构造函数。 base 关键字可带参数使用，也可不带参数使用。 构造函数的任何参数都可用作 base 的参数，或用作表达式的一部分。

e

默认构造函数

不带任何参数的构造函数称为“默认构造函数”。 每当使用 new 运算符实例化对象且不为 new 提供任何参数时，会调用默认构造函数。

如果没有为类提供构造函数，默认情况下，C# 将创建一个会实例化对象并将成员变量设置为默认值的构造函数。 如果没有为结构提供构造函数，C# 将依赖于隐式默认构造函数，自动将值类型的每个字段初始化为其默认值。

静态构造函数

静态构造函数用于初始化任何静态数据，或执行仅需执行一次的特定操作。

类或结构也可以具有静态构造函数，该静态构造函数初始化类型的静态成员。 静态构造函数是无参数构造函数。 如果未提供静态构造函数来初始化静态字段，C# 编译器将提供默认静态构造函数

静态构造函数具有以下属性：

• 静态构造函数不使用访问修饰符或不具有参数。

• 在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数以初始化类。

• 不能直接调用静态构造函数。

• 用户无法控制在程序中执行静态构造函数的时间。

• 静态构造函数的一种典型用法是在类使用日志文件且将构造函数用于将条目写入到此文件中时使用。

• 静态构造函数对于创建非托管代码的包装类也非常有用，这种情况下构造函数可调用 LoadLibrary 方法。

• 如果静态构造函数引发异常，运行时将不会再次调用该函数，并且类型在程序运行所在的应用程序域的生存期内将保持未初始化。

实例构造函数

使用 new 表达式创建类的对象时，实例构造函数可用于创建和初始化任意实例成员变量。 若要初始化静态类或非静态类中的静态变量，必须定义静态构造函数。

abstract class Shape
{
    public const double pi = Math.PI;
    protected double x, y;

    public Shape(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public abstract double Area();
}

class Circle : Shape
{
    public Circle(double radius)
        : base(radius, 0)
    {
    }
    public override double Area()
    {
        return pi * x * x;
    }
}

class Cylinder : Circle
{
    public Cylinder(double radius, double height)
        : base(radius)
    {
        y = height;
    }

    public override double Area()
    {
        return (2 * base.Area()) + (2 * pi * x * y);
    }
}

class TestShapes
{
    static void Main()
    {
        double radius = 2.5;
        double height = 3.0;

        Circle ring = new Circle(radius);
        Cylinder tube = new Cylinder(radius, height);

        Console.WriteLine("Area of the circle = {0:F2}", ring.Area());
        Console.WriteLine("Area of the cylinder = {0:F2}", tube.Area());

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    Area of the circle = 19.63
    Area of the cylinder = 86.39
*/

私有构造函数

私有构造函数是一种特殊的实例构造函数。 它通常用于只包含静态成员的类中。 如果类具有一个或多个私有构造函数而没有公共构造函数，则其他类（除嵌套类外）无法创建该类的实例。

声明空构造函数可阻止自动生成默认构造函数。 请注意，如果不对构造函数使用访问修饰符，则在默认情况下它仍为私有构造函数。 但是，通常会显式地使用 private 修饰符来清楚地表明该类不能被实例化。

编写复制构造函数

该函数使用 Person 的实例作为其参数。 该参数的属性值分配给 Person 的新实例的属性。

class Person
{
    // Copy constructor.
    public Person(Person previousPerson)
    {
        Name = previousPerson.Name;
        Age = previousPerson.Age;
    }

    //// Alternate copy constructor calls the instance constructor.
    //public Person(Person previousPerson)
    //    : this(previousPerson.Name, previousPerson.Age)
    //{
    //}

    // Instance constructor.
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public int Age { get; set; }

    public string Name { get; set; }
    
    public string Details()
    {
        return Name + " is " + Age.ToString();
    }
}

class TestPerson
{
    static void Main()
    {
        // Create a Person object by using the instance constructor.
        Person person1 = new Person("George", 40);

        // Create another Person object, copying person1.
        Person person2 = new Person(person1);

        // Change each person's age. 
        person1.Age = 39;
        person2.Age = 41;

        // Change person2's name.
        person2.Name = "Charles";

        // Show details to verify that the name and age fields are distinct.
        Console.WriteLine(person1.Details());
        Console.WriteLine(person2.Details());

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output: 
// George is 39
// Charles is 41