.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
            }
        }
    }

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