C#面向对象之多态。

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();
        }
    }