实现多态有几种方式？

基本上是重载、接口、继承 可通过这三种方式实现 多态

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。多态性通过派生类重载基类中的虚函数型方法来实现。
可以用不同的方式实现组件中的多态性：
接口多态性。
继承多态性。
通过抽象类实现的多态性。


1.利用继承，让派生类来重写父类的方法
[csharp] view plaincopy
class Program  
    {  
        static void Main(string[] args)  
        {  
            Anmial a1 = new Anmial();  
            Dog d1 = new Dog();  
            Anmial da = new Dog();  
  
            List<Anmial> list = new List<Anmial>();  
            list.Add(a1);  
            list.Add(d1);  
            list.Add(da);  
            foreach(Anmial a in list)  
            {  
                a.Say();  
            }  
            Console.ReadKey();  
        }  
    }  
  
    class Anmial  
    {  
        public virtual void Say()  
        {  
            Console.WriteLine("Anmial Say");  
        }  
         
    }  
  
    class Dog : Anmial  
    {  
        public override void Say()  
        {  
            Console.WriteLine("Dog Say");  
        }  
    }  
  
    class Mouse : Anmial  
    {  
  
        public override void Say()  
        {  
            Console.WriteLine("Mouse Say");  
        }  
    }  
  
  
  
  
  
  
   class Cat:Anmial  
  
  
  
  
     {  
  
  
  
  
  
  
       //........没有重写方法的时候，调用的是父类的方法,(因为是继承了父类的方法)  
     }  
运行结果:
Anmial Say
Dog Say
Dog Say

2.抽象类的抽象方法实现多态
[csharp] view plaincopy
class Program  
   {  
       static void Main(string[] args)  
       {  
           Anmial a1 = new Cat();  
           Anmial d1 = new Dog();  
            
           List<Anmial> list = new List<Anmial>();  
           list.Add(a1);  
           list.Add(d1);  
  
           foreach (var a in list)  
           {  
               a.Say();  
           }  
           Console.ReadKey();  
       }  
   }  
   /// <summary>  
   /// 抽象类中只能声明，方法，属性，索引器,字段等，不能被实例化  
   /// </summary>  
   public abstract class Anmial  
   {  
       public void Fly()  
       {  
           Console.WriteLine("飞");  
       }  
       public abstract void Say();//抽象方法，没有方法的实现体  
   }  
  
   class Cat:Anmial  
   {  
  
       public override void Say()  
       {  
           Console.WriteLine("猫叫");  
       }  
   }  
  
   class Dog : Anmial  
   {  
       public override void Say()  
       {  
           Console.WriteLine("狗叫");  
       }  
   }  
3.接口实现多态
[csharp] view plaincopy
class Program  
    {  
        static void Main(string[] args)  
        {  
            Anmial a1 = new Dog();  
            Anmial c1 = new Cat();  
            List<Anmial> list = new List<Anmial>();  
            list.Add(a1);  
            list.Add(c1);  
            foreach(var a in list)  
            {  
                a.Say();  
            }  
            Console.ReadKey();  
        }  
    }  
    interface Anmial  
    {  
        void Say();  
    }  
  
    class Dog : Anmial  
    {  
        #region Anmial 成员  
  
        public void Say()  
        {  
            Console.WriteLine("狗叫");  
        }  

        #endregion  
    }  
  
    class Cat : Anmial  
    {  
        #region Anmial 成员  
  
        public void Say()  
        {  
            Console.WriteLine("猫叫");  
        }  

        #endregion  
    }  

这三种方式实现多态有那些区别呢？
//接口多定义对象行为，抽象类定义对象属性

实现多态主要就是重写和重载，重写就是子类将父类中的虚方法按照自己想达到的目的重新编写，重载就是同一个类中有多个方法名相同但参数列表不同的方法，那调用这个类中的这些方法用一个方法名就可以，只要传入不同的参数就能达到不同的效果。

1.利用继承，让派生类来重写父类的方法
2.抽象类的抽象方法实现多态
3.接口实现多态

多态分为两种：
一种是继承所表现出来的多态：
在运行时，在方法参数和集合或数组等位置，派生类的对象可以作为基类的对象处理。发生此情况时，该对象的声明类型不再与运行时类型相同。
二是由虚函数实现的多态
基类可以定义并实现虚方法，派生类可以重写这些方法，即派生类提供自己的定义和实现。在运行时，客户端代码调用该方法，CLR 查找对象的运行时类型，并调用虚方法的重写方法。因此，您可以在源代码中调用基类的方法，但执行该方法的派生类版本。

可以通过接口、继承、重写来实现多态；最好是通过接口，从VS中查看方法的源定义就可以发现类实现的接口相比继承的父类要多，而且接口的使用更加灵活多变。在就业班中的设计模式中就用的接口