C#基础篇第十二天--下

多态

实现多态的三个方法：
1.虚方法 2.抽象类 3.接口

虚方法

首先将父类的函数标记为虚方法，在父类的方法返回之前加关键字virtual。
在子类的方法返回前加override。

class Program
    {
        static void Main(string[] args)
        {
            Chinese c1 =new Chinese( "张三");
            Chinese c2 = new Chinese("李四");
            Jepense j1 = new Jepense("树下");
            Jepense j2 = new Jepense("井上");
            English e1 = new English("杰克");
            English e2 = new English("丹尼");
            Person[] per = { c1, c2, j1, j2, e1, e2 };
            for (int i = 0; i < per.Length; i++)
            {
                per[i].sayhello();
            }
            Console.ReadKey();
        }
    }
    public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public Person(string name)
        {
            this. Name = name;
        }
        public virtual void  sayhello()//将父类的方法标记为了虚方法
        {
            Console.WriteLine("我是人类");
        }
    }
    public class Chinese:Person
    {
        public Chinese(string name) : base(name)
        {
             
        }
        public override void sayhello()
        {
            Console.WriteLine("我是中国人，我叫{0}",this.Name);
        }
    }
    public class Jepense:Person
    {
        public Jepense(string name) : base(name)
        { 
        }
        public override void sayhello()
        {
            Console.WriteLine("我是日本人，我叫{0}",this.Name);
        }
    }
    public class English:Person
    {
        public English(string name) : base(name)
        { }
        public override void sayhello()
        {
            Console.WriteLine("我是英国人，我叫{0}",this.Name);
        }
    }

抽象类

当父类中的方法不知如何去实现的时候，可以将父类写成抽象类，将方法写成抽象方法。
特点:

1. 抽象成员必须标记为abstract，并且不能有任何实现。
2. 抽象成员必须在抽象类中。
3. 抽象类不能被实例化。
4. 子类继承抽象类后，必须把父类中的所有抽象成员都重写。（除非子类也是一个抽象类，则可以不重写）
5. 抽象成员的访问修饰符不能是private
6. 在抽象类中可以包含实例成员，并且抽象类中的实例成员可以不被子类实现
7. 抽象类是有构造函数的，虽然不能被实例化
8. 如果父类的抽象方法中有参数，那么，继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数，如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候也必须要传入返回值。

class Program
    {
        static void Main(string[] args)
        {
            Animal a = new Dog();
            Animal b = new Mao();
            a.Bark();
            b.Bark();
            Console.ReadKey();
        }
    }
    public abstract class Animal
    {
        public abstract void Bark();
    }
    public class Dog:Animal
    {
        public override void Bark()
        {
            Console.WriteLine("狗狗会叫");
        }
    }
    public class Mao : Animal
    {
        public override void Bark()
        {
            Console.WriteLine("猫咪也会叫");
        }
    }