一、构造方法
类的构造方法是类的成员方法的一种，它的作用是对类中的成员进行初始化操作。类的构造方法分为：
1.静态构造方法
2.实例构造方法
1.静态构造方法
类的静态构造方法是类的成员方法的一种，它的作用是对类中的静态成员进行初始化操作。下面请看代码实例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
using System;namespace LycheeTest { class Test { //定义一个静态成员变量 private static int a; //定义静态构造函数 static Test() { //初始化静态成员变量 a = 11; } public void Show() { Console.WriteLine("静态字段 a 的值是：{0}", a); } } class Program { static void Main(string[] args) { Test t = new Test(); t.Show(); Console.ReadKey(); } }} |
首先，上面这段代码定义了两个类。第 3 行代码定义了类 Test。定义类的时候，类的访问权限修饰符有两个，一个是 public，另一个是 internal。当不写任何访问修饰符的时候，类的访问权限默认是 internal。 这个访问权限的意义是，这个类只能被本程序集访问，不能被本程序集以外的类访问。如果这个类是属于类库的，那么它必须是 public 的，否则调用它的程序集就不能访问它。第 5 行代码定义了一个静态字段成员，第 7 行代码就是静态构造方法。可以看到，静态构造方法的特点是，以 static 关键字说明这个方法是静态的，方法名称要和类名完全相同，这里要注意大小写。静态构造方法不能含有参数，静态构造方法不能有返回值。在静态构造方法体内可以做初始化静态成员的操作。第 11 行代码定义了一个实例方法，它的作用是输出静态字段的值。在第 16 行的类 Program 中的 Main（注意：在java中是main） 方法中调用了这个类，第 18行创建了这个类的一个实例，第 19 行 调用了类的实例方法。
从上面的代码中可以看到，并没有显式调用类的静态构造方法。
下面请看以上代码的执行结果：
静态字段 a 的值是：11
可以看到，静态构造方法确实是被执行了。那么上例就是静态构造方法的执行条件之一，在类的实例被创建时，类的静态构造方法将被自动调用。
静态构造方法的调用次序是在静态字段的初始值设定项之后。
也就是第一步是静态字段的默认值设置，第二步是执行静态字段的初始值设定项，第三步就是调用类的静态构造方法。
下面将前面的代码实例修改一下，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
using System;namespace LycheeTest{ class Test { private static int a; static Test() { a++; } public void Show() { Console.WriteLine("静态字段 a 的值是：{0}", a); 14 } } class Program { static void Main(string[] args) { Test t = new Test(); t.Show(); Test t1 = new Test(); t.Show(); Console.ReadKey(); } }} |
这段代码将静态构造方法做了修改，在方法体内将静态字段 a 进行自增操作。然后在代码的第 17 行又 创建了一个类的实例，然后再次调用类的实例方法。
下面看执行结果：
|
1
2
|
静态字段 a 的值是：1 静态字段 a 的值是：1 |
可以看到，静态字段的值并没有增加。这就是静态构造方法执行的特点，它只执行了一次。当程序集 运行的时候，将会创建一个应用程序域，在一个应用程序域中，类的静态构造方法仅仅执行一次。
下面再对代码实例进行修改如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
using System;namespace LycheeTest { class Test { public static int a; static Test() { Console.WriteLine("类的静态构造方法开始执行"); a++; } public void Show() { Console.WriteLine("静态字段 a 的值是：{0}", a); } } class Program { static void Main(string[] args) { Console.WriteLine("静态字段 a 的值是：{0}", Test.a); Console.WriteLine("静态字段 a 的值是：{0}", Test.a); Console.ReadKey(); } }} |
这段代码在类的静态构造方法中打印输出了一行标记，类的静态字段的访问权限也修改为 public，这让它可以在类外被调用。在 Main 方法中两次打印输出了静态字段的值，注意在类外调用类的静态字段需要 使用类名进行引用。
下面是代码的执行结果：
|
1
2
3
|
类的静态构造方法开始执行静态字段 a 的值是：1静态字段 a 的值是：1 |
本段代码并没有创建类的实例。在引用类的静态成员之前，类的静态构造方法将被调用。这个被调用的类的静态成员包括静态字段和静态方法。这就是类的静态构造方法调用的第二个条件。
下面再对代码实例进行修改如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
using System;namespace LycheeTest { class Program { private static int a; static Program() { Console.WriteLine("类的静态构造方法被调用"); a = 11; } static void Main(string[] args) { Console.WriteLine("Main 方法被调用"); Console.WriteLine("静态字段 a 的值是：{0}", a); Console.ReadKey(); } }} |
这段代码在包含 Main 方法的类中定义了静态字段和静态构造方法。因为 Main 方法也是一个静态方法，类的静态构造方法被调用而且它是类的入口点方法，那么它和类的静态构造方法之间是谁先调用呢？下面首先来看代码的执行结果：
|
1
2
3
|
类的静态构造方法被调用Main 方法被调用静态字段 a 的值是：11 |
通过代码的执行结果可以看到，因为类的入口点方法仍然是一个静态方法，那么在任何静态成员被调用之 前，静态构造方法都首先被调用。所以，可以得出如下结论，类的静态构造方法先于类的 Main 方法被调用。
那么类的静态构造方法能否被显式调用呢？下面看代码实例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
using System;namespace LycheeTest { class Program { private static int a; static Program() { Console.WriteLine("类的静态构造方法被调用"); a = 11; } static void Main(string[] args) { Program(); Console.ReadKey(); } }} |
在这段代码中的第 10 行显式调用了类的静态构造方法，这时编译器会报错。
2.实例构造函数
类的实例构造方法是类的成员方法的一种，它的作用是对类的实例成员进行初始化操作。实例构造方法可以实现重载，在创建类的实例时，可以显式的指定不同的参数来调用重载的不同的实例构造方法。下面请看代码实例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
using System;namespace LycheeTest { class Program { private static int a; private int b = 12; private string c = "Hello World"; static Program() { Console.WriteLine("类的静态构造方法被调用"); a = 11; } public Program(int a, string s) { Console.WriteLine("带二个参数的构造方法被调用"); this.b = a; this.c = s; } public Program(int a) : this(a, "通过 this 关键字调用构造方法") { Console.WriteLine("带一个参数的构造方法被调用"); } public void Show() { Console.WriteLine("静态字段 a 的值是：{0}", a); Console.WriteLine("实例字段 b 的值是：{0}", b); Console.WriteLine("实例字段 c 的值是：{0}", c); } static void Main(string[] args) { Program p1 = new Program(33, "这是创建的实例 P1"); Program p2 = new Program(34); p1.Show(); p2.Show(); Console.ReadKey(); } } |
这段代码的第 4 行、第 5 行和第 6 行分别定义了三个字段成员，第 4 行是静态字段，第 5 行和第 6 行代码都有初始值设定项。代码的第 8 行就是一个实例构造方法的定义，实例构造方法也是以类名作为方法名，它没有返回值， 在方法名前面是访问权限修饰符，可以使用的访问权限修饰符包括 public、private 和 protected。其中的 protected 意味着构造方法只能在此类内部访问。实例构造方法可以带参数。 第 12 行代码的实例构造方法使用两个传入的参数对实例字段进行了赋值。第 17 行代码定义了带一个参数的实例构造方法，它和前一个实例构造方法形成了重载。实例构造方法可以通过 this 关键字调用其他的实例构造方法，方法就是在参数列表的后面使用冒号然后接 this 关键字， 然后再跟参数列表，这个参数列表要匹配另一个重载的实例构造方法。第 17 行的构造方法只有一个参数， 它将这个参数通过 this 关键字传递给了另一个构造方法，在用 this 调用另一个构造方法的时候，为其同时传入了一个字符串参数。第 24 行的实例方法打印类的字段成员的值。在 Main 方法中，第 26 行代码和第 27 行代码分别定义了两个实例，它们使用 new 关键字调用了不同的实例构造方法。第 28 行和第 29 行分别调用实例方法打印类的静态字段和实例的两个字段成员的值。
下面先来看代码的执行结果：
|
1
2
3
4
5
6
|
类的静态构造方法被调用 带二个参数的构造方法被调用 带二个参数的构造方法被调用 带一个参数的构造方法被调用 静态字段 a 的值是：11 实例字段 b 的值是：33实例字段 c 的值是：这是创建的实例 P1 静态字段 a 的值是：11实例字段 b 的值是：34实例字段 c 的值是：通过 this 关键字调用构造方法 |
现在用执行结果来介绍实例构造方法的执行过程，当第 26 行代码创建类的实例时，类的静态字段首先被设置成默认值，因为没有字段的初始值设定项，所以接着就执行类的静态构造方法。这时静态字段 a 被 设置成 11。因为第 26 行代码使用 new 调用了带有两个参数的实例构造方法，所以首先实例字段 b 被设置为 0，实例字段 c 被设置为 null。然后执行字段的初始值设定项，b 被赋值为 12，c 被赋值为“Hello World”。接 下来执行实例构造方法体中的第一个语句，“带二个参数的构造方法被调用”这个字符串被打印。接下来 实例 p1 的字段 b 被设置为传入的参数 33，注意构造方法的形参 a 在这里覆盖了类的静态字段 a。也就是说， 这时起作用的是实例构造方法的局部变量 a。然后实例字段 c 被设置为字符串"这是创建的实例 P1"。第 27 行代码使用 new 关键字调用了带一个参数的实例构造方法，在调用时，首先属于 p2 的实例字段 b 被设置为 0，实例字段 c 被设置为 null。然后执行字段的初始值设定项，b 被赋值为 12，c 被赋值为“Hello World”。接下来执行的是 this 引用的带两个参数的实例构造方法，"带二个参数的构造方法被调用"这个 字符串被打印。然后 b 被设置为 34，c 被设置为"通过 this 关键字调用构造方法"。最后，代码控制又返回 来执行带一个参数的实例构造方法体中的打印语句，"带一个参数的构造方法被调用"这个字符串被打印。 至此，实例构造方法的执行完毕。接下来的代码打印静态字段的值，可以看到两个实例打印出来的静态字段值是一样的，但是它们的实 例字段的值各不相同。
可选参数和命名参数也可以用于实例构造方法，下面看代码实例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
using System;namespace LycheeTest { class Program { private int b; private string c; public Program(int a = 12, string s = "") { this.b = a; this.c = s; } public void Show() { Console.WriteLine("实例字段 b 的值是：{0}", b); Console.WriteLine("实例字段 c 的值是：{0}", c); } static void Main(string[] args) { Program p1 = new Program(); //构造方法的两个参数都采用默认值 Program p2 = new Program(34); //构造方法的 string 类型参数采用默认值 Program p3 = new Program(23, "Hello World"); //构造方法的两个参数采用传入参数 Program p4 = new Program(s: "今天的天气真好"); //采用命名参数，另一个参数 a 采用默认值 p1.Show(); p2.Show(); p3.Show(); p4.Show(); Console.ReadKey(); } }} |
代码的第 6 行定义了一个带有可选参数和命名参数的构造方法，然后第 15 创建了一个类的实例，在构造方法中没有传入任何参数，这时，构造方法的两个参数都采用默认值。第 16 行代码为构造方法传入了一个 int 类型的参数，这时，另一个 string 类型的参数采用默认值。 第 17 行代码传入了两个参数，构造方法的两个参数都使用了这两个传入的参数。第 18 行代码使用了命名参数指定传入的参数是 string 类型的参数，并将它传递给形参 s。这时另一 个 int 类型的参数采用默认值。第 19 行到第 23 行代码打印类的实例字段的值。这段代码的执行结果如下：
|
1
2
3
4
5
6
7
|
实例字段 b 的值是：12 实例字段 c 的值是： 实例字段 b 的值是：34 实例字段 c 的值是： 实例字段 b 的值是：23实例字段 c 的值是：Hello World 实例字段 b 的值是：12实例字段 c 的值是：今天的天气真好 |
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持服务器之家！
原文链接：http://www.cnblogs.com/liyongke/p/6323744.html
