面向对象之多态的三种方式

多态是面向对象最重要的特征之一，它能使得单一的类变得更多种类。简单来说多态主要有三种形式，分别是虚方法、接口和抽象类，三者各有特点，下面是代码对他们的描述：

 class Program
    {
        static void Main(string[] args)
        {
            //1.virtual method
            Chinese ch1 = new Chinese("周润发");
            Chinese ch2 = new Chinese("刘德华");
            American am1 = new American("奥巴马");
            American am2 = new American("克林顿");
            Person[] persons = { ch1, ch2, am1, am2 };
            for (int i = 0; i < persons.Length; i++)
            {
                //if (persons[i] is Chinese)
                //{
                //    ((Chinese)persons[i]).SayHello();
                //}
                //else if (persons[i] is American)
                //{
                //    ((American)persons[i]).SayHello();
                //}
                //如果在父类中不用virtual方法，子类中不用override方法，我们需要上面的一段来实现，如果有更多的子类的话，
                //那上面的判断可能会更多，相比之下下面的一句代码显得更为简洁。
                persons[i].SayHello();
            }

            //2.abstract class
            Animal a = new Dog();
            Animal b = new Cat();
            //Animal c = new Animal();抽象类不能被实例化
            a.Bark();
            b.Bark();

            //3.interface
            IFly bird = new Bird();
            IFly student = new Student();
            bird.Fly();
            student.Fly();
            Console.ReadLine();
        }
    }
    ///如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。
    ///如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。
    #region virtual method
    /// <summary>
    /// 将父类的方法标记为虚方法 ，使用关键字 virtual，这个函数可以被子类重新写一个遍。
    /// </summary>
    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()
        {
            //base.SayHello();
            Console.WriteLine("你好，我是中国人，我叫{0}.", this.Name);
        }
    }
    public class American : Person
    {
        public American(string name) : base(name) { }
        public override void SayHello()
        {
            //base.SayHello();
            Console.WriteLine("你好，我是美国人,我叫{0}.", this.Name);
        }
    }
    #endregion

    #region abstract class
    /// <summary>
    /// 1.抽象类中的抽象方法不能有方法体，但是非抽象方法可以有方法体
    /// 2.抽象类中的抽象成员必须在子类中全部实现
    /// 3.抽象成员的访问修饰符不能是private
    /// 4.抽象类不能被实例化
    /// 5.抽象类可以有构造函数，接口则没有
    /// </summary>
    public abstract class Animal
    {
        private int age;

        public int Age
        {
            get
            {
                return age;
            }

            set
            {
                age = value;
            }
        }
        public Animal(int age)
        {
            this.Age = age;
        }
        public abstract string Name { get; set; }
        public virtual void T()
        {
            Console.WriteLine("动物有声明。。。");
        }
        public abstract void Bark();
        public void Eat() { }
        public Animal() { }

    }
    public class Dog : Animal
    {
        public override void Bark()
        {
            Console.WriteLine("狗狗有声明。。。");
        }
        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }

            set
            {
                throw new NotImplementedException();
            }
        }
    }
    public class Cat : Animal
    {
        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }

            set
            {
                throw new NotImplementedException();
            }
        }

        public override void Bark()
        {
            Console.WriteLine("猫咪有声明。。。");
        }
    }
    #endregion

    #region interface
    /// <summary>
    /// 1.接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为public,不能修改。
    /// 2.接口中只能有方法、属性、索引器、事件，不能有“字段”和构造函数。
    /// 3.一个类可以同时继承一个类并实现多个接口，如果一个子类同时继承了父类A，并实现了接口IA,那么语法上A必须写在IA的前面。
    /// </summary>
    public interface IFly
    {
        void Fly();//不允许有访问修饰符，默认是public
    }
    public class Bird : IFly
    {
        public void Fly()
        {
            Console.WriteLine("鸟儿在飞。。。");
        }
    }
    public class Student : IFly
    {
        public void Fly()
        {
            Console.WriteLine("人类在飞。。。");
        }
    }
    #endregion