C＃高级（三）构造函数

构造函数是和类名相同的类的一个方法，如果没有显式的声明，在系统会在编译的时候，自动生成一个不带参数的，不执行任何动作的构造函数。

       但如果显式的声明了构造函数，系统就不会自动生成了。如果声明的构造函数是有参数的构造函数，我们在实例化类的时候，就必须以该构造函数而实例化类。看下面的代码:

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class test
5.     {
6.         public int num;
7.         public   test (int i)
8.         {
9.             this.num=i+5;
10.         }
11.         
12.         static void Main()
13.         {
14.                 test classOne=new test(10); 
15.                 int x=classOne.num; 
16.                 Console.WriteLine(x); 
17.         }
18.     }
19. }

如上代码，在实例化类的时候，test classOne=new test(10); 传递了一个参数。如果我们test classOne=new test();这样来实例化类，就会报错了。因为我们显式的声明了一个带参的构造方法，new test() 这样实例化的时候，调用的是无参的构造函数，但类中却没有无参的构造函数。

 

       我们再来看一下静态构造函数。

在C# 中我们可以给类定义一个无参的静态构造函数（注意，必须是无参的），只要创建类的对象，该方法就会执行。该函数只执行一次，并且在代码引用类之前执行。

一般，在类中有一些静态字段或者属性，需要在第一次使用类之前从外部数据源初始化这些静态字段和属性，这时，我们就采用静态构造函数的方式来解决。

静态构造函数没有访问修饰符，其他C#代码也不调用它，在加载类时，总是由.NET 运行库调用它。一个类只能有一个静态构造函数。

注意，无参的实例构造函数可以和静态构造函数在类中共存。因为静态构造函数是在加载类的时候执行的，而实例构造函数是在创建实例时执行的，两者并不冲突。

我们看下面的例子

 

 

 

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class test
5.     {
6.         static test()
7.         {
8.             Console.WriteLine("www.gosoa.com.cn");
9.         }
10.         public   test ()
11.         {                        
12.         }
13.         
14.         static void Main()
15.         {
16.                 test classOne=new test();   
17.         }
18.     }
19. }

该程序运行的结果是 www.gosoa.com.cn 在类的对象创建的时候，静态构造函数已经运行了。

我们再来看一个例子

 

 

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class test
5.     {
6.         private string domain;
7.         private string url;
8.         public   test (string dom,string url)
9.         {
10.             this.domain=dom;
11.             this.url=url;
12.         }
13.         public test(string dom)  
14.         {
15.             this.domain=dom;
16.             this.url="gosoa.com.cn";
17.         }
18.         
19.         static void Main()
20.         {
21.             test classOne=new test("gosoa");
22.             Console.WriteLine(classOne.url);
23.         }
24.     }
25. }

在上例中，有两个构造函数，有可能两个构造函数需要初始化同一个字段，这种情况，C#中有个特殊的语言，称为“构造函数初始化器”可以实现。看下面代码

 

1. using System;
2. namespace gosoa.com.cn
3. {
4.     public class test
5.     {
6.         private string domain;
7.         private string url;
8.         public   test (string dom,string url)
9.         {
10.             this.domain=dom;
11.             this.url=url;
12.         }
13.         public test(string dom)  : this (dom,"www.gosoa.com.cn")
14.         {           
15.         }
16.         
17.         static void Main()
18.         {
19.             test classOne=new test("gosoa");
20.             Console.WriteLine(classOne.url);
21.         }
22.     }
23. }

如上实例，就是采用了 构造函数初始化器。注意，构造函数初始化器在构造函数之前执行。

 

2、只读字段(readonly)。

       只读字段比常量灵活的多，常量(const)字段必须在声明之初就初始化，但readonly字段甚至可以进行一些运算再确定其值。

       注意，可以在构造函数中对只读字段赋值，但不能在其他地方赋值。