（教学思路 C#之类四）构造方法（静态构造方法、this、方法重载）、析构方法（修改新增）

 1  class StaticTest 
 2        { 
 3                 //如果i没有初值，编译器不会自动创建静态构造方法。 
 4                 public  static  int i = 1; 
 5 
 6                 //创建自定义的静态构造器，观察它的执行顺序。 
 7                 static StaticTest() 
 8                { 
 9                        Console.WriteLine( "我应该在1的前面被调用,我只被调用一次。"); 
10                } 
11 
12                 //定义私有的实例变量j和s，不赋初值 
13                 int j; 
14                 string s; 
15 
16              //定义无参的构造器，同时给j和s赋值 
17                 public StaticTest() 
18                { 
19                        Console.WriteLine( "我是无参构造器！,我给j赋值后，只要继承我，使用：this（），你们的j和s都是这个值"); 
20                        j = 10; 
21                        s =  "原来的值"; 
22                } 
23 
24                 //通过：this（）方式，继承了j和s的值 
25 
26                 public StaticTest( string ss): this() 
27                { 
28                         //此时j=10，如果没有继承，j=0. 
29                        Console.WriteLine( "j=" + j); 
30 
31                         //通过传参进入的值，改变了继承了无参构造器中s的值， 
32                         //说明即使继承了s的值，也可以在本构造方法中改变s的值 
33                        s = ss; 
34                        Console.WriteLine(s); 
35                        
36                } 
37        } 
38         class Program 
39        { 
40                 static  void Main( string[] args) 
41                { 
42                         //先调用静态成员i的值，结果会是先执行静态构造方法，再显示i=1; 
43                        Console.WriteLine( "用我前，先会查看是否有静态构造方法的定义，如果有先执行它，再得出i="+StaticTest.i); 
44                        Console.WriteLine( "-------------"); 
45 
46                         //此时不会再出现static构造器的内容，因为前面已经执行了一次。 
47                        StaticTest A =  new StaticTest(); 
48                        Console.WriteLine( "-------------"); 
49 
50                         //观察j和s值的变化： 
51                        StaticTest B =  new StaticTest( "s的值改变了"); 
52 
53                } 
54        }

class Class1                                    可以看出，类在继承时，构造函数在实例化的过程中，是会被再次调用的。 
        {    
                 static  void Main()    
                {    
                        Console.WriteLine( "**********");    
                        A a =  new A();    
                        Console.WriteLine( "**********");    
                        B b =  new B();    
                        Console.WriteLine( "***** AC : A*****");    
                        AC ac =  new AC();    
                        Console.WriteLine( "*****BC : B*****");    
                        BC bc =  new BC();    
                        Console.WriteLine( "*****CC : AC*****");    
                        CC cc =  new CC();    
                        Console.WriteLine( "*****CCC : BC*****");    
                        CCC ccc =  new CCC();    
                }    
        }    
         class A    
        {    
                 public A()    
                {    
                        Console.WriteLine( "Call method A()");    
                }    
        }    
         class B    
        {    
                 public B()    
                {    
                        Console.WriteLine( "Call method B()");    
                }    
        }    
         class AC : A    
        {    
                 public AC()    
                {    
                        Console.WriteLine( "Call method AC()");    
                }    
        }    
         class BC : B    
        {    
                 public BC()    
                {    
                        Console.WriteLine( "Call method BC()");    
                }    
        }    
         class CC : AC    
        {    
                 public CC()    
                {    
                        Console.WriteLine( "Call method CC()");    
                }    
        }    
         class CCC : BC    
        {    
                 public CCC()    
                {    
                        Console.WriteLine( "Call method CCC()");    
                }

namespace hello 
{ 
         //创建一个人类Ren 
         class Ren 
        { 
                 //虽然我把析构方法写在最上面的，但是它是最后执行的方法。 
                ~Ren() 
                { 
                        Console.WriteLine( "灭亡了"); 
                } 
                 /*观察字段成员如果不赋初值时，在创建对象的时候， 
                 * 编译器会按照类型默认的给变量一个初值，如年龄、姓名 
                 * 我们可以在构造方法中，对未赋值的字段进行改变，如年龄 
                 * 如果字段已经赋初值了，那么创建对象的时候， 
                 * 就会使用初值，如果需要改变，就在构造方法中重新赋值即可，如性别*/ 
 
                 //定义一个年龄变量，不赋初值 
                 int age; 
                 //定义一个姓名变量，不赋初值 
                 string name; 
                 //定义一个性别变量，赋初值为男 
                 string Sex =  "男"; 
 
                 //定义一个方法，读取类中字段成员，值的变化。 
                 void Say() 
                { 
                        Console.WriteLine( "我的年龄:{0}，我的名字:{1}，我的性别:{2}", age, name,Sex ); 
                } 
 
 
                 /*1.以下方法都为Ren这个类的构造方法，他们因为参数不同，形成了方法的重载， 
                 * 2.this关键字：this关键字用来引用对象本身，已经是说，this.name指的是对象中的name字段， 
                 *     而=name的这个name指的是方法中离它定义最近的name，这里值的是构造方法中传入的name参数 
                 * this关键字在例子结束后，还会具体的讲解。*/     
                    
                 //在无参的构造方法中，给性别重新赋值，年龄和姓名按照创建对象时默认的赋初值 
                 public Ren() 
                { 
                         //改变性别的值 
                        Sex =  "女"; 
                        Console.WriteLine( "我刚出生！还没有名字，年龄也从0岁开始！"); 
                         //此时读取对象中的字段值的变化，应该性别改变，年龄和姓名都为默认值 
                        Say(); 
                }    
            
                 //创建一个带姓名参数的构造方法，将创建对象时传入的name参数赋给对象中的字段name值，这样say方法中的姓名也有了改变 
                 //同时在这个构造方法中，给age字段自定义赋值。 
                 public Ren(  string name ) 
                {    
                      this. name =name ; 
                     Console.WriteLine( "呦！我使用双截棍，我有名字了！，但是年龄呢？,我自己定，我就27岁了。"); 
                     age = 27; 
                     Say(); 
                } 
 
                 //创建一个带姓名参数、姓名的构造方法，将创建对象时传入的name参数赋给对象中的字段name值， 
                 //将创建对象时传入的age参数的值赋给对象中的字段age，这样say方法中的姓名、年邻都有了改变 
                
                     public Ren( int age,  string name) 
                { 
                         this.age = age; 
                         this.name = name; 
                        Console.WriteLine( "哦！你给我起名字，告诉我多大了吧！你说的算！"); 
                        Say(); 
                } 
 
                
                 //定义静态的构造函数，我把她放在在最后，但是会第一个被调用。 
                     static Ren() 
                    { 
                            Console.WriteLine( "我是静态的构造函数，不能有参数及访问修饰符，并且创建对象时，我只执行一次，最先调用"); 
                            Console.WriteLine(); 
                    } 
                    
        } 
         class Program 
        { 
                 static  void Main( string[] args) 
                { 
                         //创建无参的对象boby，并且创建时会先调用静态的构造方法，再调用无参的构造方法 
                        Ren boby =  new Ren(); 
                        Console.WriteLine(); 
 
                         //创建有姓名参数的对象songer歌手 
                        Ren songer =  new Ren( "周杰伦"); 
                        Console.WriteLine(); 
 
                         //创建有年龄、姓名参数的对象man 
                        Ren man =  new Ren(33, "贝克汉姆"); 
                        Console.WriteLine(); 
                } 
 
        } 
}