VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > Python基础教程 >
  • C#教程之c#核心基础--类的构造方法

一、构造方法

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

    1.静态构造方法

    2.实例构造方法

    3.私有构造方法

  1.静态构造方法

  类的静态构造方法是类的成员方法的一种,它的作用是对类中的静态成员进行初始化操作。下面请看代码实例:

复制代码
 1 using System;
 2 namespace LycheeTest {
 3     class Test {
 4         //定义一个静态成员变量
 5         private static int a;
 6         //定义静态构造函数
 7         static Test() {
 8             //初始化静态成员变量
 9             a = 11;
10         }
11         public void Show() {
12             Console.WriteLine("静态字段 a 的值是:{0}", a);
13             
14         }
15     }
16     class Program {
17         static void Main(string[] args) {
18             Test t = new Test();
19             t.Show();
20             Console.ReadKey();
21         }
22     }
23 }       
复制代码

   首先,上面这段代码定义了两个类。第 3 行代码定义了类 Test。定义类的时候,类的访问权限修饰符有两个,一个是 public,另一个是 internal。当不写任何访问修饰符的时候,类的访问权限默认是 internal。 这个访问权限的意义是,这个类只能被本程序集访问,不能被本程序集以外的类访问。如果这个类是属于类库的,那么它必须是 public 的,否则调用它的程序集就不能访问它。第 5 行代码定义了一个静态字段成员,第 7 行代码就是静态构造方法。可以看到,静态构造方法的特点是,以 static 关键字说明这个方法是静态的,方法名称要和类名完全相同,这里要注意大小写。静态构造方法不能含有参数,静态构造方法不能有返回值。在静态构造方法体内可以做初始化静态成员的操作。第 11 行代码定义了一个实例方法,它的作用是输出静态字段的值。在第 16 行的类 Program 中的 Main(注意:在java中是main) 方法中调用了这个类,第 18行创建了这个类的一个实例,第 19 行 调用了类的实例方法。

  从上面的代码中可以看到,并没有显式调用类的静态构造方法。

  下面请看以上代码的执行结果:

 静态字段 a 的值是:11  

  可以看到,静态构造方法确实是被执行了。那么上例就是静态构造方法的执行条件之一,在类的实例被创建时,类的静态构造方法将被自动调用。

  静态构造方法的调用次序是在静态字段的初始值设定项之后。

  也就是第一步是静态字段的默认值设置,第二步是执行静态字段的初始值设定项,第三步就是调用类的静态构造方法。

  下面将前面的代码实例修改一下,代码如下:

复制代码
 1 using System;
 2 namespace LycheeTest{
 3     class Test {
 4         private static int a;
 5         static Test() {
 6             a++;
 7         }
 8         public void Show() {
 9             Console.WriteLine("静态字段 a 的值是:{0}", a);
10             14
11         }
12     }
13     class Program {
14         static void Main(string[] args) {
15             Test t = new Test();
16             t.Show();
17             Test t1 = new Test();
18             t.Show();
19             Console.ReadKey();
20         }
21     }
22 }
复制代码

  这段代码将静态构造方法做了修改,在方法体内将静态字段 a 进行自增操作。然后在代码的第 17 行又 创建了一个类的实例,然后再次调用类的实例方法。

  下面看执行结果:

静态字段 a 的值是:1 
静态字段 a 的值是:1

  可以看到,静态字段的值并没有增加。这就是静态构造方法执行的特点,它只执行了一次。当程序集 运行的时候,将会创建一个应用程序域,在一个应用程序域中,类的静态构造方法仅仅执行一次。

  下面再对代码实例进行修改如下:

复制代码
 1 using System;
 2 namespace LycheeTest {
 3     class Test {
 4         public static int a;
 5         static Test() {
 6             Console.WriteLine("类的静态构造方法开始执行");
 7             a++;
 8         }
 9         public void Show() {
10             Console.WriteLine("静态字段 a 的值是:{0}", a);
11         }
12     }
13     class Program {
14         static void Main(string[] args) {
15             Console.WriteLine("静态字段 a 的值是:{0}", Test.a);
16             Console.WriteLine("静态字段 a 的值是:{0}", Test.a);
17             Console.ReadKey();
18         }
19     }
20 }
复制代码

  这段代码在类的静态构造方法中打印输出了一行标记,类的静态字段的访问权限也修改为 public,这让它可以在类外被调用。在 Main 方法中两次打印输出了静态字段的值,注意在类外调用类的静态字段需要 使用类名进行引用。

  下面是代码的执行结果:

类的静态构造方法开始执行 
静态字段 a 的值是:1 
静态字段 a 的值是:1

  本段代码并没有创建类的实例。在引用类的静态成员之前,类的静态构造方法将被调用。这个被调用的类的静态成员包括静态字段和静态方法。这就是类的静态构造方法调用的第二个条件。

  下面再对代码实例进行修改如下: 

复制代码
 1 using System;
 2 namespace LycheeTest {
 3     class Program {
 4         private static int a;
 5         static Program() {
 6             Console.WriteLine("类的静态构造方法被调用");
 7             a = 11;
 8         }
 9         static void Main(string[] args) {
10             Console.WriteLine("Main 方法被调用");
11             Console.WriteLine("静态字段 a 的值是:{0}", a);
12             Console.ReadKey();
13         }
14     }
15 }
复制代码

   这段代码在包含 Main 方法的类中定义了静态字段和静态构造方法。因为 Main 方法也是一个静态方法,类的静态构造方法被调用而且它是类的入口点方法,那么它和类的静态构造方法之间是谁先调用呢?下面首先来看代码的执行结果:

类的静态构造方法被调用
Main 方法被调用 
静态字段 a 的值是:11

  通过代码的执行结果可以看到,因为类的入口点方法仍然是一个静态方法,那么在任何静态成员被调用之 前,静态构造方法都首先被调用。所以,可以得出如下结论,类的静态构造方法先于类的 Main 方法被调用。

  那么类的静态构造方法能否被显式调用呢?下面看代码实例:

复制代码
 1 using System;
 2 namespace LycheeTest {
 3     class Program {
 4         private static int a;
 5         static Program() {
 6             Console.WriteLine("类的静态构造方法被调用");
 7             a = 11;
 8         }
 9         static void Main(string[] args) {
10             Program();
11             Console.ReadKey();
12         }
13     }
14 }
复制代码

  在这段代码中的第 10 行显式调用了类的静态构造方法,这时编译器会报错。

  2.实例构造函数

  类的实例构造方法是类的成员方法的一种,它的作用是对类的实例成员进行初始化操作。实例构造方法可以实现重载,在创建类的实例时,可以显式的指定不同的参数来调用重载的不同的实例构造方法。下面请看代码实例:

复制代码
 1 using System;
 2 namespace LycheeTest {
 3     class Program {
 4         private static int a;
 5         private int b = 12;
 6         private string c = "Hello World";
 7 
 8         static Program() {
 9             Console.WriteLine("类的静态构造方法被调用");
10             a = 11;
11         }
12         public Program(int a, string s) {
13             Console.WriteLine("带二个参数的构造方法被调用");
14             this.b = a;
15             this.c = s;
16         }
17         public Program(int a) : this(a, "通过 this 关键字调用构造方法") {
18             Console.WriteLine("带一个参数的构造方法被调用");
19         }
20         public void Show() {
21             Console.WriteLine("静态字段 a 的值是:{0}", a);
22             Console.WriteLine("实例字段 b 的值是:{0}", b);
23             Console.WriteLine("实例字段 c 的值是:{0}", c);
24         }
25         static void Main(string[] args) {
26             Program p1 = new Program(33, "这是创建的实例 P1");
27             Program p2 = new Program(34);
28             p1.Show();
29             p2.Show();
30             Console.ReadKey();
31         }
32     }
复制代码

  这段代码的第 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 行分别调用实例方法打印类的静态字段和实例的两个字段成员的值。

  下面先来看代码的执行结果:

类的静态构造方法被调用 带二个参数的构造方法被调用 带二个参数的构造方法被调用 带一个参数的构造方法被调用 
静态字段 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 using System;
 2 namespace LycheeTest {
 3     class Program {
 4         private int b;
 5         private string c;
 6         public Program(int a = 12, string s = "") {
 7             this.b = a;
 8             this.c = s;
 9         }
10         public void Show() {
11             Console.WriteLine("实例字段 b 的值是:{0}", b);
12             Console.WriteLine("实例字段 c 的值是:{0}", c);
13         }
14         static void Main(string[] args) {
15             Program p1 = new Program(); //构造方法的两个参数都采用默认值
16             Program p2 = new Program(34); //构造方法的 string 类型参数采用默认值
17             Program p3 = new Program(23, "Hello World"); //构造方法的两个参数采用传入参数
18             Program p4 = new Program(s: "今天的天气真好"); //采用命名参数,另一个参数 a 采用默认值
19             p1.Show();
20             p2.Show();
21             p3.Show();
22             p4.Show();
23             Console.ReadKey();
24         }
25     }
26 }
复制代码

  代码的第 6 行定义了一个带有可选参数和命名参数的构造方法,然后第 15 创建了一个类的实例,在构造方法中没有传入任何参数,这时,构造方法的两个参数都采用默认值。第 16 行代码为构造方法传入了一个 int 类型的参数,这时,另一个 string 类型的参数采用默认值。 第 17 行代码传入了两个参数,构造方法的两个参数都使用了这两个传入的参数。第 18 行代码使用了命名参数指定传入的参数是 string 类型的参数,并将它传递给形参 s。这时另一 个 int 类型的参数采用默认值。第 19 行到第 23 行代码打印类的实例字段的值。这段代码的执行结果如下

 

复制代码
实例字段 b 的值是:12 
实例字段 c 的值是: 
实例字段 b 的值是:34 
实例字段 c 的值是: 
实例字段 b 的值是:23
实例字段 c 的值是:Hello World 实例字段 b 的值是:12
实例字段 c 的值是:今天的天气真好
复制代码

 3.私有构造函数

   私有构造方法就是访问权限修饰符为 private 的实例构造方法。将访问权限修饰符设置为 private 有 两个目的,一是它不能被继承;二是它不能实例化。所以,使用私有构造方法通常用来设计工具类,即这 个类通过一些静态成员来完成某些操作,而不必要实例化这个类。下面是代码实例:

 

复制代码
 1 using System;
 2 namespace LycheeTest {
 3     class Test {
 4         private Test() {}
 5         private const float PI = 3.14159265358979F;
 6         public static float Area(float r) {
 7             return PI * r * r;
 8         }
 9     }
10     class Program {
11         static void Main(string[] args) {
12             Console.WriteLine("请输入圆的半径:");
13             float r = Convert.ToSingle(Console.ReadLine());
14             float area = Test.Area(r);
15             Console.WriteLine("圆的面积为:{0}", area);
16             Console.ReadKey();
17         }
18     }
19 }
复制代码

 第 4 行代码简单地定义了一个 private 的无参构造方法就将类定义成了一个无法实例化的类。第 5 行定义了一个常量 PI,第 6 行定义了一个静态的方法 Area 来计算圆的面积,这个方法要求传入 一个 float 类型的圆的半径。第 13 行代码将用户输入的字符串转化成 float 类型的变量,第 14 行代码调用类 Test 的静态方法来求 圆的面积,并将结果赋值给了变量 area。第 15 行打印输出圆的面积。可以看到,求圆的面积没有必要实例化类,而只需要类的静态方法的功能就可以了。可以说,项目需要的就是一个工具类,在这种情况下,定义一个私有构造方法就可以解决问题。


相关教程