C#的多态性

参考网址：http://www.cnblogs.com/zhangkai2237/archive/2012/12/20/2826734.html

多态的定义：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。

在理解多态之前了解几个概念：重载，重写，虚方法，抽象方法以及隐藏方法。

1、重载：在同一个作用域（一般指一个类）两个或多个方法函数名相同，参数列表不同的方法叫做重载，他们有三个特点

  (1)方法名必须相同

 （2）参数列表必须不相同

  (3)返回值类型可以不相同

public void Sleep(){
  cw("Animal睡觉");  
}
public int sleep(){
  cw("Animal几点睡觉");
}
public void Sleep(int time)
{
    cw("Animal{0}点睡觉",time);
}　

2、重写：子类中满足自己的需要来重复定义某个方法的不同实现，需要用override关键字，被重写的方法必须是虚方法，用的是virtual关键字。

  (1)相同的方法名。

  (2)相同的参数列表。

  (3)相同的返回值。

父类中的定义：
  public virtual void EatFood()
 {
    cw("Animal吃东西")  ;
 }
 
 子类中的定义
 public override void EatFood(){
    cw("cat吃东西"); 
} 
  

 tips：虚方法能直接被调用

4、抽象方法：在基类中定义的并且在派生类中重写的方法，使用abstract关键字定义。如：

  

基类：
public abstract class Biology
{
   public abstract void Live();  
}

子类
public class Animal:Biology
{
   public override void Live()
  {
     cw("Animal重写的抽象方法");
  }
}

tips ：抽象类中可以包含抽象类，也可以包含已经实现的。
         已经实现的类不能包含抽象类。

5、隐藏方法：在派生类中定义的和基类中的某个方法同名的方法，使用new关键字定义。如在基类Animal中有一方法sleep();

  public void Sleep(){
     cw("Animal Sleep");
  }

  在派生类cat中定义隐藏方法的代码为：
  new public void Sleep(){
     cw("Cat Sleep");
 }
 或
  public new void Sleep()
{
    cw("Cat Sleep");  
}

tips：(1)隐藏方法不但可以隐藏基类中的虚方法，而且可以隐藏基类中的非虚方法
        (2)隐藏方法中父类的实例调用父类的方法，子类的实例调用子类的方法
        (3)和上条对比：重写方法中子类的变量调用子类重写的方法，父类的变量要看这个父类引用的是子类的实例还是本身的实例，如果调用的是父类的实例，那么调用基类的方法，如果引用的是派生类的实例，则调用派生类的方法。

详细解说：
 class Program
    {
        static void Main(string[] args)
        {
            //Animal 的实例
            Animal a = new Animal();
            a.EatFood();
            //Animal 的实例，引用派生类Cat对象
            Animal ac = new Cat();
            ac.EatFood();
            ac.Sleep();

            Cat c = new Cat();
            c.Sleep();
            //Animal的实例，引用派生类Dog对象
            Animal ad = new Dog();
            Console.ReadKey();

        }
    }

    public abstract class Biology
    {
        public abstract void Live();
    }

    public class Animal : Biology
    {
        public override void Live()
        {
            Console.WriteLine("Animal重写的Live");
        }

        public void Sleep()
        {
            Console.WriteLine("Animal Sleep");
        }

        public int Sleep(int time)
        {
            Console.WriteLine("Animal在{0}点Sleep",time);
            return time;
        }

        public virtual void EatFood()
        {
            Console.WriteLine("Animal EatFood");
        }
    }

    public class Cat : Animal
    {
        public override void EatFood()
        {
            Console.WriteLine("Cat EatFood");
        }
        new public void Sleep()
        {
            Console.WriteLine("Cat Sleep");
        }
    }

    public class Dog : Animal
    {
        public override void EatFood()
        {
            Console.WriteLine("Dog EatFood");
        }
    }

父类 animal   子类 cat
当出现 Animal a=new Cat(); 时，调用的是父类的 的方法。
当出现 Cat c=new Cat();时，调用的是子类的隐藏方法。