1、定义：指不同的对象收到相同的消息时，会产生不同的行为，同一个类在不同的场合下表现出不同的行为特征。

比如。

 class Program
    {
　　　　　　//下面三各类都继承object，但不同类的tostring（）有不同的表现。
        static void Main(string[] args)
        {
            object o = new object();
            Console.WriteLine(o.ToString());
            Person person = new Person();
            Console.WriteLine(person.ToString());
            string msg = "你好";
            Console.WriteLine(msg.ToString());
        }
    }
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

 多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，作出通用的编程，以适应需求的不断变化。

2、实现多态。

 

虚方法实现方法重写来实现多态。

class Program
    {
        //希望person存的是哪个类的对象就调用哪个类的方法
        //第一步  将父类中对应方法家virtual关键字  变为虚方法（子类可重写）
        //子类中方法用override关键字将父类虚方法重写
        static void Main(string[] args)
        {
            Person[] person = new Person[3];
            person[0] = new American();
            person[1] = new Japan();
            person[2] = new Chinese();
            for (int i = 0; i < person.Length; i++)
            {
                //由于person是Person类的，如果我想让每个人说出他的国籍
                //只能判断类型然后强制转换：
                //if (person[0]is American)
                //{
                //    ((American)person[0]).Say();
                //}
                //希望person存的是哪个类的对象就调用哪个类的方法
                //第一步  将父类中对应方法家virtual关键字  变为虚方法（子类可重写）
                //子类中方法用override关键字将父类虚方法重写
                person[i].Say(); //这句话就体现了多态

            }

        }
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public virtual void Say()
        {
            Console.Write("Person");
        }
    }
    public class American:Person
    {
        public override void Say()
        {
            Console.WriteLine("美国人");
        }
    }
    public class Japan:Person
    {
        public override void Say()
        {
            Console.WriteLine("日本人");
        }
    }
    public class Chinese : Person
    {
        public override void Say()
        {
            Console.WriteLine("中国人");
        }
    }

例子中，把所有子类都当作Person类来对待，屏蔽掉了各个子类的不同成员（.点不出来），其中person[i].Say();就是通用的代码。

通过抽象类实现多态：

 抽象类：1、类前加abstract  2、。。3、抽象成员不能有实现  4、 抽象成员必须包含在抽象类中。 5、抽象类不能用来实例化对象（作用：被继承----实现多态）  6、抽象成员子类继承后必须重写，除非子类也是抽象类。 （就像领导，只告诉员工要做什么）

实现：和上面虚方法类似，利用重写来实现。

抽象类和虚方法选哪个：如果需要实例化或者父类中有默认的实现就选虚方法，否则用抽象类。

例子：

 

 

class Program
    {
        static void Main(string[] args)
        {
            Pc pc = new Pc();
            All udisk = new UDisk();
            pc.Device = udisk;
            pc.PCRead();
            pc.PCWrite();
            
        }
    }
    public abstract class All
    {
        public abstract void Read();
        public abstract void Write();
    }
    public class Mp3 : All
    {
        public override void Read()
        {
            Console.WriteLine("Mp3读");
        }

        public override void Write()
        {
            Console.WriteLine("Mp3写");
        }
    }
    public class UDisk : All
    {
        public override void Read()
        {
            Console.WriteLine("udisk read");
        }

        public override void Write()
        {
            Console.WriteLine("udisk write");
        }
    }
    public class Pc
    {
        public All  Device{ get; set; }
        public void PCRead()
        {
            Device.Read();
        }
        public void PCWrite()
        {
            Device.Write();
        }
    }