1. namespace 多态
   
2. {
   
3.     class Program
   
4.     {
   
5.         static void Main(string[] args)
   
6.         {
   
7.             Person p = new Person();
   
8.             p.Say();
   
9. 
   
10.             Student s = new Student();
    
11.             s.Say();
    
12. 
    
13.             Teacher t = new Teacher();
    
14.             t.Say();
    
15. 
    
16.             Console.ReadKey();
    
17.         }
    
18.     }
    
19. 
    
20.     public class Person//创建Person
    
21.     {
    
22.         string _name;
    
23.         public string Name
    
24.         {
    
25.             get { return _name; }
    
26.             set { _name = value; }
    
27.         }
    
28. 
    
29.         int _age;
    
30.         public int Age
    
31.         {
    
32.             get { return _age; }
    
33.             set { _age = value; }
    
34.         }
    
35. 
    
36.         public void Say()
    
37.         { Console.WriteLine("我是人"); }
    
38. 
    
39.     }
    
40.     public class Student : Person
    
41.     {
    
42. 
    
43.         public void Say()
    
44.         { Console.WriteLine("我是学生"); }
    
45.     }
    
46. 
    
47.     public class Teacher : Person
    
48.     {
    
49. 
    
50.         public void Say()
    
51.         { Console.WriteLine("我是老师"); }
    
52.     }
    
53. }

复制代码

这样进行写代码会提示说是否隐藏基类方法用关键字new
可是在创建person实例，student实例，teacher实例后，对象调用的不就是自身类中的方法吗？加上new与 不加new最后显示结果一样，那为何还要加上new，单步调试的时候子类对象调用方法也没有经过父类啊  能否具体解释一下

这里的new写与不写，本质一样。加关键字new后，是为了让编译时不会产生警告而已，执行原理都一样，只能隐藏基类的方法，而不能重写它。new只是把基类的方法隐藏了，实际上基类还是有实例的,比如你代码中的基类Person的方法,用new之后p.say();仍然是存在的。隐藏是为子类提供便利的，这也是多态的方便所在。我们可以通过改变引用的声明类型来使用不同的方法。但是隐藏父类方法一般都尽量避免，不推荐这么做，所以有机会还是用override重写吧。

隐藏基类成员的方法有两种：

第一种在子类中定义相同前面的成员，并在声明前加new。（当然不用new直接定义相同的成员也可，但是可能会有警告）
第二种在父类中把方法定义为virtual，在子类中覆写方法override。

两种不同点：前者当把子类转化成父类时，调用方法仍然调用父类的方法。而后者当把子类转化为父类时，调用的仍然是子类的方法，换句话说，子类把父类的virtual给覆盖了。如果有几层调用，会调用最下面的最子类的子类方法。

了然了