详解c# 类的构造方法

时间:2021-12-25 04:49:53

一、构造方法

类的构造方法是类的成员方法的一种,它的作用是对类中的成员进行初始化操作。类的构造方法分为:

    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