1. 
   
2. <P> </P>

复制代码

1. namespace ConsoleApplication1
   
2. {
   
3. class Program
   
4. {
   
5. static void Main(string[] args)
   
6. {
   
7. person[] p = new person[2];
   
8. chiness c = new chiness();
   
9. jp j = new jp();
   
10. p[0] = c;
    
11. p[1] = j;
    
12. c.Name = "张三";
    
13. j.Name = "李四";
    
14. for (int i = 0; i < p.Length; i++)
    
15. {
    
16. p[i].sayhi();
    
17. 
    
18. }
    
19. Console.ReadKey();
    
20. }
    
21. }
    
22. class person
    
23. {
    
24. private int age;
    
25. 
    
26. public int Age
    
27. {
    
28. get { return age; }
    
29. set { age = value; }
    
30. }
    
31. private string name;
    
32. 
    
33. public string Name
    
34. {
    
35. get { return name; }
    
36. set { name = value; }
    
37. }
    
38. virtual public void sayhi()
    
39. {
    
40. Console.WriteLine("我的年龄:{0}我的姓名:{1}",this.age,this.name);
    
41. }
    
42. }
    
43. class chiness : person
    
44. {
    
45. override public void sayhi()
    
46. {
    
47. Console.WriteLine("我是中国人我叫:{0}", Name);
    
48. }
    
49. }
    
50. class jp : person
    
51. {
    
52. override public void sayhi()
    
53. {
    
54. Console.WriteLine("我是日本人我叫:{0}",Name);
    
55. }
    
56. }
    
57. }
    

复制代码

谁给解释一下 上面的这段代码

一个person类派生了一个chinese类和jp类，其中chinese类重写了父类sayhi()方法，jp类重写了父类sayhi()方法。

namespace ConsoleApplication1              //命名空间
{
    class Program                           //主程序
    {
        static void Main(string[] args)     //主程序起始方法
         {
             person[] p = new person[2];   //声明Person数组，分配2个位置
             chiness c = new chiness();   //实例化chiness类c
             jp j = new jp();             //实例化jp类j
             p[0] = c;                     //把c放入声明的Person类的第一个位置
             p[1] = j;                     //把j放入声明的Person类的第二个位置
             c.Name = "张三";              //c的Name字段赋值“张三”
             j.Name = "李四";              //j的Name字段赋值“李四”
             for (int i = 0; i < p.Length; i++) //for循环取出p中的内容，也就是上面放入的c,j
             {
                 p[i].sayhi();                //索引形式调用sayhi()方法
             }
             Console.ReadKey();                //程序等待键入.....
         }
     }
   class person                         //声明Person父类
    {
        private int age;               //声明私有字段age
        public int Age                 // 封装age字段，此时Age 是属性
        {
        get { return age; }            //当调用Age点是取值，比如 p.Age
        set { age = value; }}            //当给Age赋值
        }
        private string name;             //同上
        public string Name
        {
        get { return name; }
        set { name = value; }
        }
        public virtual  void sayhi()    //声明sayhi()方法，病标记为虚拟，子类中可以重写
        {
        Console.WriteLine("我的年龄:{0}我的姓名:{1}",this.age,this.name);   //方法体
        }
    }
    class chiness : person          //chinese类继承person
    {
        public override  void sayhi()   //override 标志重写父类虚方法，
        {
        Console.WriteLine("我是中国人我叫:{0}", Name);  //方法体
        }
    }
    class jp : person                //jp类继承person
    {
        public override  void sayhi()   //override 标志重写父类虚方法，
        {
        Console.WriteLine("我是日本人我叫:{0}",Name);  //方法体
        }
    }
}


//希望对你有帮助

2楼的解释好强大.跪了.

刘逍遥 发表于 2012-6-22 13:37
namespace ConsoleApplication1              //命名空间
{
    class Program                            ...

哥们辛苦了，怪我呀。没说明白,我想问的是为什么可以通过父类的sayhi()调用了 不同的对象的sayhi();

鲍云龙 发表于 2012-6-22 13:54
哥们辛苦了，怪我呀。没说明白,我想问的是为什么可以通过父类的sayhi()调用了 不同的对象的sayhi(); ...

你不是用override标记把父类的sayhi()方法重写了吗？ 重写的意思就是：不用父类方法体，用我子类的方法体！

因为你把子类放在Person类数组后，根据循环每次取出来的是子类的实例，当然调用的是子类实例的方法

此处并不是用父类的方法去调用子类方法，而是你用循环取出的是子类的实例对象，是直接调用子类的sayhi（）方法！  并不是通过父类来掉子类方法

刘逍遥 发表于 2012-6-22 13:58
你不是用override标记把父类的sayhi()方法重写了吗？ 重写的意思就是：不用父类方法体，用我子类的方法体 ...

楼主说的我认为不太对吧，父类只无法调用子类里重写的方法了吧，它只能调用它自身方法，子类可以调用父类的方法

程艳伟 发表于 2012-6-22 19:07
楼主说的我认为不太对吧，父类只无法调用子类里重写的方法了吧，它只能调用它自身方法，子类可以调用父类 ...

如果子类重写父类方法，那么调用的是，子类方法
如果没重写，则调用父类方法
父类肯定只能调用父类方法

刘逍遥 发表于 2012-6-22 19:23
如果子类重写父类方法，那么调用的是，子类方法
如果没重写，则调用父类方法
父类肯定只能调用父类方法 ...

我又研究了一下这代码。其实这就是传说中的多态

鲍云龙 发表于 2012-6-22 21:16
我又研究了一下这代码。其实这就是传说中的多态

namespace 子类继承关系
{
    class Program
    {
        static void Main(string[] args)
        {
            F f=new F();  //实例化父类对象f
            S s = new S();  //实例化子类对象s
            f.Say();    //父类调用父类方法
            s.Say();    //子类调用子类方法
            f=(F)s;     
            f.Say();   //父类调用子类重写的方法
            Console.ReadKey();

        }
    }
    public class F  //定义父类
    {
        public virtual void  Say()
        {
            Console.WriteLine("我是父类");
        }
    }
    public class S:F //子类S继承于F类
    {
        public override void  Say()
        {
            Console.WriteLine("我是子类");
        }
    }
}