baidixing 阅读(143) 评论(0)

    构造函数这个概念,在我们刚开始学习编程语言的时候,就被老师一遍一遍的教着。亲,现在你还记得静态构造函数的适用场景吗?如果没有,那么我们一起来复习一下吧。

静态构造函数是在构造函数方法前面添加了static关键字之后形成的,并且没有修饰符(public,private),没有参数。

静态构造函数有哪些特点呢:

  1. 静态构造函数没有修饰符修饰(public,private),因为静态构造函数不是我们程序员调用的,是由.net 框架在合适的时机调用的。
  2. 静态构造函数没有参数,因为框架不可能知道我们需要在函数中添加什么参数,所以规定不能使用参数。
  3. 静态构造函数前面必须是static 关键字。如果不加这个关键字,那就是普通的构造函数了。
  4. 静态构造函数中不能实例化实例变量。(变量可以分为类级别和实例级别的变量,其中类级别的有static关键字修饰)。
  5. 静态函数的调用时机,是在类被实例化或者静态成员被调用的时候进行调用,并且是由.net框架来调用静态构造函数来初始化静态成员变量。
  6. 一个类中只能有一个静态构造函数。
  7. 无参数的静态构造函数和无参数的构造函数是可以并存的。因为他们一个属于类级别,一个属于实例级别,并不冲突。
  8. 静态构造函数只会被执行一次。并且是在特点5中的调用时机中进行调用。
  9. 就像如果没有在类中写构造函数,那么框架会为我们生成一个构造函数,那么如果我们在类中定义了静态变量,但是又没有定义静态构造函数,那么框架也会帮助我们来生成一个静态构造函数来让框架自身来调用。

上面几个特点都是理论性的,我们来做一个找错题,帮助我们一起来学习静态构造函数。

 1     public class C
 2     {
 3         public static string BB;
 4         public static C()
 5         {
 6             BB = "CC";
 7         }
 8         public static C(string mm)
 9         {
10             BB = mm;
11         }
12         static C()
13         {
14             BB = "Right";
15         }
16         public C()
17         {
18             BB = "Wrong";
19         }
20         public C(string mm)
21         {
22             BB = mm;
23         }
24     }

VS编译提示的错误信息:

 

现在我们来做一个有意思的事情,验证静态构造函数的调用时机:

 1  class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5 
 6             Console.WriteLine(A.strText);
 7             Console.WriteLine(B.strText);
 8             Console.Read();
 9         }
10     }
11     public class A
12     {
13         public static string strText;
14         public string Text;
15         static A()
16         {
17             strText = "AAA";
18         }
19         public A()
20         {
21             Text = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
22         }
23     }
24     public class B:A
25     {
26         static B()
27         {
28             strText = "BBB";
29         }
30         public B()
31         {
32             Text = "BBBBBBBBBBBBBBBBB";
33         }
34     }

输出结果均为:AAA

我们来分析一下出现这个情况的原因所在,当显示A.strText的时候,因为strText是静态变量,所以框架会调用A的静态构造函数,此时strText的值为AAA.正确

当显示B.strText的时候,因为B继承自A,所以会首先调用A的静态构造函数,但是因为静态构造函数只会调用一次,所以不会调用A的静态构造函数,但是又因为strText属于类A,而不是B,所以B得静态构造函数不会执行,故输出的均为AAA。

 

但是如果我们把输出更改一下,输出结果就大不一样了。

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             B b = new B();
 6             A a = new A();
 7 
 8             Console.WriteLine(A.strText);
 9             Console.WriteLine(B.strText);
10           
11             Console.Read();
12         }
13     }
14     public class A
15     {
16         public static string strText;
17         public string Text;
18         static A()
19         {
20             strText = "AAA";
21         }
22         public A()
23         {
24             Text = "AAAAAAAAAAAAAAAAAAAAAAAAAA";
25         }
26     }
27     public class B:A
28     {
29         static B()
30         {
31             strText = "BBB";
32         }
33         public B()
34         {
35             Text = "BBBBBBBBBBBBBBBBB";
36         }
37     }

请注意我在开始部分对类进行了实例化,那么此时的输出结果就是均为BBB。

为什么会有这样的情况出现呢,其实还是要从静态构造函数的调用时机入手。

首先我们实例化了B,此时会调用B的静态构造函数,但是因为strText是A的静态变量,所以首先会先调用A的静态构造函数将strText赋值为AAA,此时又会调用B的静态构造函数将strText赋值为BBB,所以此时strText的值应该为BBB,所以输出均为BBB。