C#之构造函数

C#构造函数

1.概念：构造函数是一种特殊的成员函数,它主要用于为对象分配存储空间,对数据成员进行初始化.

2.性质：构造函数具有一些特殊的性质:

(1)构造函数的名字必须与类同名;

(2)构造函数没有返回类型,它可以带参数,也可以不带参数;

(3)声明类对象时,系统自动调用构造函数,构造函数不能被显式调用;

(4)构造函数可以重载,从而提供初始化类对象的不同方法;

(5)若在声明时未定义构造函数,系统会自动生成默认的构造函数,此时构造函数的函数体为空.

(6)静态构造函数,用static修饰，用于初始化静态变量，一个类只允许有一个构造函数，在类实例化时加载，这时修饰符public、private失去作用.

(7)可以使用public、protected、private修饰符。.

(8)引用父类构造时用（）：base（）方法，引用自身重载的构造使用（）：this（int para）.

(7)可以使用public、protected、private修饰符。

3.构造函数父与子的结构层次关系及其执行顺序：

    从基类开始构造对象，当创建派生类的对象时，系统将会调用基类的构造函数和派生类的构造函数

    构造函数的执行次序是：先执行基类的构造函数，再执行派生类的构造函数。如果派生类又有对象成员，则，先执行基类的构造函数，再执行成员对象类的构造函数，最后执行派生类的构造函数。至于执行基类的什么构造函数，缺省情况下是执行基类的无参构造函数，如果要执行基类的有参构造函数，则必须在派生类构造函数的成员初始化表中指出

public  class MyBaseClass
    {
         public MyBaseClass()
        {
            Console.WriteLine( " In MyBaseClass() ");
        }
         public MyBaseClass( int i)
        {
            Console.WriteLine( " In MyBaseClass(int i) ");
        }
    }
     public  class MyDerivedClass : MyBaseClass
    {
         public MyDerivedClass()
        {
            Console.WriteLine( " In MyDerivedClass() ");
        }
         public MyDerivedClass( int i)
        {
            Console.WriteLine( " In MyDerivedClass(int i) ");
        }
         // public MyDerivedClass(int i, int j)
         // {
         //     Console.WriteLine("In MyDerivedClass(int i,int j)");
         // }
         public MyDerivedClass( int i,  int j)
            :  base(i)
        {
            Console.WriteLine( " In MyDerivedClass(int i,int j):base(i) ");
        }
    }
     class Program
    {
         static  void Main( string[] args)
        {
             // Event1
            MyDerivedClass myObj1 =  new MyDerivedClass();
            Console.WriteLine();
             // Event2
            MyDerivedClass myObj2 =  new MyDerivedClass( 4);
            Console.WriteLine();
             // Event3
            MyDerivedClass myObj3 =  new MyDerivedClass( 4, 8);
            Console.WriteLine();
            Console.ReadKey();
        }
    }

 

程序输出：

 

In MyBaseClass()

In MyDerivedClass()

 

In MyBaseClass()

In MyDerivedClass(int i)

 

In MyBaseClass(int i)

In MyDerivedClass(int i,int j):base(i)

很明显，只有在用base显示调用父类的构造函数时，程序才不会默认的调用不带参数的构造函数。

4.分类：构造函数分为：
             1.实例构造函数
             2.私有构造函数
     3.静态构造函数

构造函数是一种特殊的方法，主要是为了给初始化对象赋初值。
1.实例构造函数

使用new 表达式创建某个类 的对象时，会使用实例构造函数创建和初始化所有实例成员变量。

  public   class  ProgramTest
    {
         int  j;
         public  ProgramTest()
        {
            j  =   4 ;
            Console.WriteLine( " I am ProgramTest,{0} " ,  j );
        }
         static   void  Main( string [] args)
        {
            ProgramTest pt  =   new  ProgramTest();
            Console.Read();
        }

结果为：I am ProgramTest,4

在此次实验中，我们首先定义了一个私有成员j，经过初始化给他赋了一个初值4，当我实例化类ProgramTest时，就会执行实例构造函数。
诸如此类不带参数的构造函数叫“默认构造函数”， 如果某个类没有构造函数，则会自动生成一个默认构造函数，并使用默认值来初始化对象字段。

public   class  ProgramTest
    {
         int  j;
         public  ProgramTest()
        {
            Console.WriteLine( " I am ProgramTest,{0} " , j);
        }
         static   void  Main( string [] args)
        {
            ProgramTest pt  =   new  ProgramTest();
            Console.Read();
        }

    }
结果为：I am ProgramTest, 0   

也可以创建带有参数的构造函数

  public   class  ProgramTest
    {
         int  j;
         public  ProgramTest( int  i)
        {
            j  =   2 ;
            Console.WriteLine( " I am ProgramTest,i={0},j={1} " ,i, j);
        }
         static   void  Main( string [] args)
        {
            ProgramTest pt  =   new  ProgramTest( 1 );
            Console.Read();
        }

 

结果为：I am ProgramTest i=1,j= 2 

 

那若是一个类中既有无参构造函数，又有有参构造函数那会怎么样呢？

  public   class  ProgramTest
    {
         int  j;
         public  ProgramTest()
        {
            j  =   3 ;
            Console.WriteLine( " I am ProgramTest 默认构造函数,j={0} " , j);
        }
         public  ProgramTest( int  i)
        {
            j  =   2 ;
            Console.WriteLine( " I am ProgramTest 有参构造函数,i={0},j={1} " ,i, j);
        }
         static   void  Main( string [] args)
        {
            ProgramTest pt1  =   new  ProgramTest();
            ProgramTest pt2  =   new  ProgramTest( 1 );
            Console.Read();
        }

 

结果为：I am ProgramTest 默认构造函数 j= 3
        I am ProgramTest 有参构造函数 i=1,j=2

 

可见，若是两者同时存在，那么看类实例化时，是怎么实例的。
2.私有构造函数

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

 

    public   class  Test
    {
         private   Test()
        {
            Console.WriteLine( " I am Test " );
        }
    }
     public   class  ProgramTest
    {
         int  j;
         private  ProgramTest()
        {
            j  =   3 ;
            Console.WriteLine( " I am ProgramTest 默认构造函数,j={0} " , j);
        }
         static   void  Main( string [] args)
        {
            Test t  =   new  Test();
            ProgramTest pt1  =   new  ProgramTest();
            Console.Read();
        }
    }

结果：这时你会发现编译器会提示你，你无法创建Test的实例
（即使你在Test类中添加一个静态成员，结果依然会提示因为该构造函数受其保护级别的限制而不可访问)

若是只在自己类里有私有类呢？

   public   class  ProgramTest
    {
         int  j;
         private  ProgramTest()
        {
            j  =   3 ;
            Console.WriteLine( " I am ProgramTest 默认构造函数,j={0} " , j);
        }
         static   void  Main( string [] args)
        {
            ProgramTest pt1  =   new  ProgramTest();
            Console.Read();
        }
    }

结果：I am ProgranmTest 默认构造函数，j=3

注意，如果您不对构造函数使用访问修饰符，则在默认情况下它仍为私有构造函数。但是，通常显式地使用private修饰符来清楚地表明该类不能被实例化。
若是一个类中既有实例构造函数又有私有构造函数，那么当实例对象是会怎么执行呢?

  public   class  Test
    {
         int  i;
         private   Test()
        {
            i  =   1 ;
            Console.WriteLine( " I am Test 默认构造函数 i={0} " , i);
        }
         public  Test( int  i)
        {
            Console.WriteLine( " I am Test 有参构造函数 i={0} " , i);
        }
    }
     public   class  ProgramTest
    {
         static   void  Main( string [] args)
        {
            Test t  =   new  Test();   //编译器提示：因为该构造函数受其保护级别的限制而不可访问        
            Console.Read();

若是只执行有参构造函数呢？

   public   class  Test
    {
         int  i;
         private   Test()
        {
            i  =   1 ;
            Console.WriteLine( " I am Test 默认构造函数 i={0} " , i);
        }
         public  Test( int  i)
        {
            Console.WriteLine( " I am Test 有参构造函数 i={0} " , i);
        }
    }
     public   class  ProgramTest
    {
         static   void  Main( string [] args)
        {
            Test t  =   new  Test( 2 );
            Console.Read();
        }
    }

结果：I am Test 有参构造函数 i=2

3.静态构造函数
静态构造函数用来初始化静态变量，这个构造函数是属于类的，而不是属于哪个实例的。

静态构造函数是实现对一个类进行初始化的方法成员。它一般用于对静态数据的初始化。静态构造函数不能有参数，不能有修饰符而且不能被调用，当类被加载时，类的静态构造函数自动被调用。如：

　　声明了一个有静态构造函数的类Employee。注意静态构造函数只能对静态数据成员进行初始化，而不能对非静态数据成员进行初始化。但是，非静态构造函数既可以对静态数据成员赋值，也可以对非静态数据成员进行初始化。

　　如果类仅包含静态成员，你可以创建一个private的构造函数：private TestClass() {…}，但是private意味着从类的外面不可能访问该构造函数。所以，它不能被调用，且没有对象可以被该类定义实例化。

就是说这个构造函数只会被执行一次。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用。

  public   class  Test
    {
         static   int  i;
         static   Test()
        {
            i  =   1 ;
            Console.WriteLine( " I am Test 默认构造函数 i={0} " , i);
        }
    }
     public   class  ProgramTest
    {
         static   void  Main( string [] args)
        {
            Test t1  =   new  Test();
            Console.Read();
        }
    }

结果为：I am Test 默认构造函数 i=1

静态构造函数的特点：

1.静态构造函数既没有访问修饰符，也没有参数。
2. 在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数来初始化类，也就是无法直接调用静态构造函数，也无法控制什么时候执行静态构造函数。

3.一个类只能有一个静态构造函数，最多只能运行一次。
4.静态构造函数不可以被继承。
5.如果没有静态构造函数，而类中的静态成员有初始值，那么编译器会自动生成默认的静态构造函数。
如果静态默认构造函数和公有默认构造函数同时存在，会怎么样呢？

 

    public   class  Test
    {
         static   int  i;
         static   Test()
        {
            i  =   1 ;
            Console.WriteLine( " I am Test 静态默认构造函数 i={0} " , i);
        }
         public  Test()
        {
            Console.WriteLine( " I am Test 公有默认构造函数 i={0} " , i);
        }
    }
     public   class  ProgramTest
    {
         static   void  Main( string [] args)
        {
            Test t1  =   new  Test();
            Console.Read();
        }
    }

结果：I am Test 静态默认构造函数 i=1

 

     I am Test 公有默认构造函数 i=1

 

 

如果静态默认构造函数和公有有参构造函数同时存在，我实例化类让它调用静态默认构造函数会怎么样呢？

  public   class  Test
    {
         static   int  i;
         static   Test()
        {
            i  =   1 ;
            Console.WriteLine( " I am Test 静态默认构造函数 i={0} " , i);
        }
         public  Test( int  j)
        {
            Console.WriteLine( " I am Test 公有有参构造函数 i={0} " , j);
        }
    }
     public   class  ProgramTest
    {
         static   void  Main( string [] args)
        {
            Test t1  =   new  Test();    //系统会提示错误       
            Console.Read();

        }

    }

如果静态默认构造函数和公有有参构造函数同时存在，我实例化类让它调用公有构造函数会怎么样呢？

    public   class  Test
    {
         static   int  i;
         static   Test()
        {
            i  =   1 ;
            Console.WriteLine( " I am Test 静态默认构造函数 i={0} " , i);
        }
         public  Test( int  j)
        {
            Console.WriteLine( " I am Test 公有有参构造函数 i={0} " , j);
        }
    }
     public   class  ProgramTest
    {
         static   void  Main( string [] args)
        {
            Test t1  =   new  Test( 2 );
            Console.Read();
        }
    }

结果：I am Test 静态默认构造函数 i=1
     I am Test 公有有参构造函数 j=2