.net构造函数

作用：初始化类的成员字段

如果没有显示声明一个构造函数，系统会默认分配一个无参的构造函数。

显示声明：

class Father
    {
        public Father()//1.签名和类名一致 2.没有返回值
        {

        }
    }

最基本的构造函数只能初始化为标准的默认值

例如：引用类型为空引用，数字类型为0，bool为false

构造函数的重载：

class Father
    {
        private string name;
        private int age;
        //构造函数的重载
        public Father(){}
        public Father(string name) { this.name = name; }
        public Father(string name, int age) { this.name = name; this.age = age; }
    }

this关键字用来区分成员字段和同名参数
私有的构造函数：

//私有的构造函数
private Father(){}

私有的构造函数可以防止不相干的类来访问，并且不能用New关键字来实例化也不能被继承。

应用场景：1.类仅用作某些静态成员或属性的容器，因此永远不会被实例化

              2.希望类仅通过调用某个静态函数来实例化（类代理）

静态构造函数：

static Father()
        { 
        
        }

静态构造函数只执行一次，实例构造函数只要创建实例就会执行。

场景：类有一些静态字段或属性，需要在第一次使用类之前，从外部源中初始化这些静态字段和属性

注意：1.静态构造函数不能用修饰符，因为该构造函数其他类从来不调用，而由.net运行库来调用所以public,private就没有意义,强制添加也会报错。

        2.静态构造函数不能有任何参数

        3.一个类只能有一个静态构造函数

        4.只能访问类的静态成员，不能访问实例成员。

 private string name;
        private static int age;
        static Father()
        {
           //name 将无法访问到
           age = 10;//age是可以的因为他是静态的
        }

        5.无参的实例构造函数可以和静态无参构造函数共存

 class Father
    {
        public Father()
        { 
        }
        static Father()
        {
        }
    }

从其他构造函数中调用构造函数：

多个版本的构造函数会出现重复的初始化

 class Father
    {
        private string name;
        private int age;

        public Father(string name)
        {
            this.name = name;
        }
        public Father(string name, int age)
        {
            this.name = name;//和上面的重复
            this.age = age;
        }
    }

我们可以使用初始化器来解决

public Father(string name)
        {
            this.name = name;
        }
        public Father(string name, int age): this(name)
        {
            this.age = age;
        }

this关键字仅用于调用最匹配的那个构造函数

注意：构造函数初始化器会在构造函数之前执行

派生类的构造函数：

在继承结构中父类必须提供一个无参的构造函数

//父类
    class Father
    {
        private string name;
        public Father(){}
        public Father(string name)
        {
            this.name = name;
        }
    }

 //子类
    class Son : Father
    {
        private string name;
        public Son(){}
        public Son(string name)
        {
            this.name = name;
        }
    }

 //三级子类
    class SmalSon : Son
    {
        private string name;
        public SmalSon(string name)
        {
            this.name = name;
        }
    }

继承下的构造函数调用顺序总是自上而下的

 static void Main(string[] args)
        {
            Father fa = new Father();
            Son son = new Son();
            Father father = new SmalSon("xiao");
        }

实例化Father 将只调用Father的构造函数

实例化Son将先调用Father的构造函数然后在调用自自身的构造函数

实例化SmalSon就会先调用Father-》Son-》SmalSon

所以，派生类可以执行它基类的方法或属性，因为其父类已经被构造出来了。

在层次结构中添加带参数的构造函数：

 //父类中没有提供默认的无参构造函数
        private string name;
        public Father(string name)
        {
            this.name = name;
        }

//子类
    class Son : Father
    {
        private string name;
        public Son(string name):base(name)//子类通过base关键字制定实例化父类的那个构造函数,name为传递给父类构造函数的参数
        {
            this.name = name;
        }
    }

base只是指定在实例化子类时候实例化父类的某个构造函数，其他什么操作都不做。