每日一测2(关于构造函数)

1、一个类中可以有多个构造函数，包括无参的默认构造函数和有参的。

2、不加修饰符或显式的用private修饰的构造函数， 表示该类不能被实例化。

3、子类的构造函数，默认会调用父类的无参构造函数，如父类的无参构造函数不存在，会报错。 也可以显式的指定调用父类的哪个构造函数

    class Person
    {
        public int test;
        static Person()
        {
            Console.WriteLine("我是父类的静态构造函数");
        }
        public Person()
        {
            test = 0;
            Console.WriteLine("我是父类的默认构造函数 " + test.ToString());
        }
        public Person(int t)
        {
            test = t;
            Console.WriteLine("我是父类的有参构造函数 " + test.ToString());
        }
    }

    class Chinese : Person
    {
        public Chinese() //默认会调用父类的默认构造函数,当父类没有默认构造函数则会报错(无法编译)
        {
            test++;
            Console.WriteLine("我是子类的默认构造函数..." + test.ToString());
        }

        public Chinese(int t)
            : base(t) //调用指定父类的构造函数
        {
            test++;
            Console.WriteLine("我是子类的有参构造函数..." + test.ToString());
        }

        static Chinese()
        {
            Console.WriteLine("我是子类的静态构造函数...");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int t = 5;
            Chinese cn = new Chinese(t);      
            Console.ReadKey();
        }
    }

执行结果：

其他例子自己跑个测试。

4、私有构造函数一般用于静态类，不能被外部实例化,却可以在内部实例化, 区别于继承

    class Person
    {
        private Person(int t) //可有参可无参
        {
            Console.WriteLine("我是私有构造函数" + t.ToString());
        }
        public static Person CreatePerson(int at)
        {
            Person P = new Person(at);
            return P;
        }

    }

    //class Chinese : Person //不能被继承的,会报错
    //{
    //}
    class Program
    {
        static void Main(string[] args)
        {
            int t = 5;
            Person temp = Person.CreatePerson(t); //不能被外部实例化,可以在类内部实例化.    
            Console.ReadKey();
        }
    }