（教学思路 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(); 
                } 
 
        } 
}