.net中的多态

封装、继承、多态是面向对象的三大特征。前面两个特征都比较好理解，在平时练习中经常会用到，但是对于多态来说就显得比较抽象，可能只有在大型的项目中才会体会到多态带来的便利性。

多态的概念：通过继承实现不同对象调用相同方法，表现出不同的行为，称为多态。

下面通过一个简单的例子来揭开多态的神秘面纱

首先定义一个基类Animal

 //定义一个父类    class Animal {        public virtual void Eat() {            Console.WriteLine("Animal Eat");        }    }

然后定义2个继承自Animal的子类Dog和Cat

 //子类Dog    class Dog : Animal {        public override void Eat()        {            Console.WriteLine("Dog Eat");        }    }

 //子类Cat    class Cat : Animal {        public override void Eat()        {            Console.WriteLine("Cat Eat");        }    }

下面是客户端实现的代码：

 class Program    {        static void Main(string[] args)        {            //通过继承，使得Animal对象数组中的不同的对象，在调用Eat()方法时，表现出了不同的行为            Animal[] am = new Animal[3];            am[0] = new Dog();            am[1] = new Cat();            am[2] = new Animal();            for (int i = 0; i < am.Length;i++ )            {                am[i].Eat();//输出Dog Eat、Cat Eat、Animal Eat            }            Console.Read();        }    }

Dog和Cat都是通过继承Animal类来重写（override）父类中的Eat方法，让每个类都拥有了自己的Eat方法。这只是多态的冰山一角，还有很多便利性。下面再来看一下在子类中的方法前面使用new关键字后产生什么样的影响。

一、使用new关键字实现多态

  //定义一个父类    class Animal1    {        public virtual void Eat()        {            Console.WriteLine("Animal Eat");        }    }

 //子类Dog    class Dog1 : Animal    {        //使用new关键字来定义子类中的Eat方法        public new  void Eat()        {            Console.WriteLine("Dog Eat");        }    }

客户端调用这两个类的代码：

 class new在类中的使用    {        public static void Main() {            Animal1 am = new Animal1();            am.Eat();            Animal newdog = new Dog1();            newdog.Eat();            Dog1 dog = new Dog1();            dog.Eat();            Console.Read();        }    }

这里输出的结果为：Animal Eat、Animal Eat、Dog Eat。为什么第二个输出的是Animal Eat呢？原来是我们在子类的Eat方法前加了new关键字后，子类中Eat方法和父类中的Eat方法就已经完全断绝了关系，我们在将子类对象Dog1转化为Animal对象后，调用Eat方法是调用的Animal中的方法。我想这是设计者有意这么设计的，因为有时候我们就是要达到这种效果。严格的说，不能说通过使用new来实现多态，只能说在某些特定的时候碰巧实现了多态的效果。

二、使用virtual--override实现多态

真正的多态使用override来实现的。回过去看前面的例1，在基类Animal中将方法Eat()用virtual标记为虚拟方法，再在派生类Cat和Dog中用override对Eat()修饰，进行重写，很简单就实现了多态。需要注意的是，要对一个类中一个方法用override修饰，该类必须从父类中继承了一个对应的用virtual修饰的虚拟方法，否则编译器将报错。

多重继承怎样实现多态呢？比如类A是基类，有一个虚拟方法method()（virtual修饰），类B继承自类A，并对method()进行重写（override修饰），现在类C又继承自类B，是不是可以继续对method()进行重写呢？

代码 public class Animal    {        public virtual void Eat()        {            Console.WriteLine("Animal eat");        }    }    public class Dog : Animal    {        public override void Eat()        {            Console.WriteLine("Dog eat");        }    }    public class WolfDog : Dog//子类有继承子类    {        public override void Eat()        {            Console.WriteLine("WolfDog eat");        }    }    class Tester    {        static void Main(string[] args)        {            Animal[] animals = new Animal[3];            animals[0] = new Animal();            animals[1] = new Dog();            animals[2] = new WolfDog();            for (int i = 0; i < 3; i++)            {                animals[i].Eat();//输出结果为：Animal eat、Dog eat、WolfDog eat。            }        }}

在上面的例子中类Dog继承自类Animal，对方法Eat()进行了重写，类WolfDog又继承自Dog，再一次对Eat()方法进行了重写，并很好地实现了多态。不管继承了多少层，都可以在子类中对父类中已经重写的方法继续进行重写，即如果父类方法用override修饰，如果子类继承了该方法，也可以用override修饰，多层继承中的多态就是这样实现的。要想终止这种重写，只需重写方法时用sealed关键字进行修饰即可。

三、使用abstract--override来实现多态

上一节我们讨论了用abstract修饰的抽象方法，抽象方法只是对方法进行了定义而没有对其进行实现，如果一个类中包含了抽象方法，那么这个类必须要用abstract申明为抽象类，抽象类是不能实例化的，对于抽象类中的抽象方法可以在子类中用override来进行重写，如果不重写，那么子类也得申明为抽象类。

看看下面的例子：

 public abstract class Animal    {　　　   public abstract void Eat();    }    public class Cat : Animal    {        public override void Eat()        {            Console.WriteLine("Cat eat");        }    }    public class Dog : Animal    {        public override void Eat()        {            Console.WriteLine("Dog eat");        }    }    public class WolfDog : Dog    {        public override void Eat()        {            Console.WriteLine("Wolfdog eat");        }    }    class Tester    {        static void Main(string[] args)        {            Animal[] animals = new Animal[3];            animals[0] = new Cat();            animals[1] = new Dog();            animals[2] = new WolfDog();            for (int i = 0; i < animals.Length; i++)            {                animals[i].Eat();//输出结果为：Cat eat、Dog eat、WolfDog eat            }        }    }

以上就是我对多态的肤浅认识。