（教学思路 C#之类八）多态性：base、new、override、virtual

    1  //定义一个F类 
    2         class F 
    3        { 
    4                 //定义一个公有Method方法，子类中用new隐藏了本方法 
    5                 public  void Method() 
    6                { 
    7                        Console.WriteLine( "我是父类中的Method方法"); 
    8                        Console.WriteLine(); 
    9                } 
 10                 //定义了一个虚方法Method1，子类中重写了Method1. 
 11                 public  virtual  void Method1() 
 12                { 
 13                        Console.WriteLine( "我是父类中的Method1方法"); 
 14                        Console.WriteLine(); 
 15                } 
 16                 //定义了一个虚方法Method2，子类中重写了Method2.子类中使用了base.method1,再次调用被重写了的Method1 
 17                 public  virtual  void Method2() 
 18                { 
 19                        Console.WriteLine( "我是父类中的Method2方法"); 
 20                        Console.WriteLine(); 
 21                } 
 22        } 
 23         //定义一个继承F类的S类 
 24         class S : F 
 25        { 
 26                 //定义一个公有Method方法，隐藏了父类的方法 
 27                 public  new  void Method() 
 28                { 
 29                        Console.WriteLine( "我是子类中的Method方法,使用new关键字，显式的隐藏父类中的同名方法"); 
 30                        Console.WriteLine(); 
 31                } 
 32                 //定义一个重写父类Method1的方法Method1。 
 33                 public  override     void Method1() 
 34                { 
 35                        Console.WriteLine( "我是子类中的Method1方法,覆盖父类中的同名方法，此时S中没有了父类中Method1方法"); 
 36                        Console.WriteLine(); 
 37                } 
 38                 //定义一个重写父类Method1的方法Method1，同时使用base调用父类的Method1。 
 39                 public  override     void Method2() 
 40                { 
 41                         
 42                        Console.WriteLine( "我是子类中的Method2，覆盖父类中的同名方法，调用base.method1"); 
 43                         base.Method1(); 
 44                        Console.WriteLine(); 
 45                } 
 46        } 
 47    
 48     
 49         class Program 
 50        { 
 51                 static  void Main( string[] args) 
 52                { 
 53                         // 创建一个S类的s对象 
 54                        S s =  new S(); 
 55                         // 创建一个F类的f对象 
 56                        F f =  new F(); 
 57 
 58                         //创建一个F类的fs对象，但是用S类来实现，这种方式是允许的。 
 59                         //意思就是父亲到了儿子的房子去了，看到的油画应该是父亲的油画，房子还是从父亲那继承下的房子。 
 60                         //对象fs所引用出的成员，实际是从父类中继承来的成员，不是继承来的成员（如儿子自己买的电器）fs是无权访问的。 
 61                         //父类需要子类去实现的这种方式会在抽象类和接口中会用到。 
 62                        F fs =  new S(); 
 63 
 64                         //先观察一下子类使用new的Method方法中三对象的结果。 
 65                          //------------------------------------------- 
 66                         //子类的对象s引用的Method方法打印出的是子类的Method方法 
 67                        s.Method(); 
 68                         //子类中的Method方法，因为使用了new，只是覆盖了父类的Method方法， 
 69                         //所以父类的对象fs引用的Method方法打印出的是还是从父类中继承下来的Method方法 
 70                        fs.Method(); 
 71                         //父类中的Method方法不变 
 72                        f.Method(); 
 73                        Console.WriteLine( "---------"); 
 74 
 75 
 76                         //先观察一下子类使用override的Method1方法中三对象的结果。 
 77                         //------------------------------------------- 
 78                         //子类的对象s引用的Method1方法打印出的是子类的Method1方法 
 79                        s.Method1(); 
 80                         //子类中的Method1方法，因为使用了override，重写了父类的Method1方法， 
 81                         //所以父类的对象fs引用的Method1方法打印出的是还是从子类中继承下来的Method1方法 
 82                         //子类中只存在子类的Method1方法,结果如上. 
 83                        fs.Method1(); 
 84                         //父类中的Method方法不变 
 85                        f.Method1(); 
 86                        Console.WriteLine( "---------"); 
 87 
 88 
 89                         //先观察一下子类使用override和base.method1的Method2方法中三对象的结果。 
 90                         //------------------------------------------- 
 91                         //因为使用了override，重写了父类的Method2方法， 
 92                         //因为使用了base.Method1,所以在子类中会调用父类的Method1方法 
 93                         //子类的对象s引用的Method1方法打印出的是子类的Method2方法和父类的Method1方法 
 94                        s.Method2(); 
 95                         //子类中的Method2方法，因为使用了override，重写了父类的Method2方法， 
 96                         //所以父类的对象fs引用的Method2方法打印出的是还是从子类中继承下来的Method2方法 
 97                         //子类中只存在子类的Method2方法,结果如上. 
 98                        fs.Method2(); 
 99                         //父类中的Method方法不变 
100                        f.Method2(); 
101                        Console.WriteLine( "---------"); 
102                } 
103        }