实现多态的几种方法

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。多态性通过派生类重载基类中的虚函数型方法来实现。

可以用不同的方式实现组件中的多态性：

• 接口多态性。
• 继承多态性。
• 通过抽象类实现的多态性。

 

 
1.利用继承，让派生类来重写父类的方法

class Program
    {
        static void Main(string[] args)
        {
            Anmial a1 = new Anmial();
            Dog d1 = new Dog();
            Anmial da = new Dog();

            List<Anmial> list = new List<Anmial>();
            (a1);
            (d1);
            (da);
            foreach(Anmial a in list)
            {
                ();
            }
            ();
        }
    }

    class Anmial
    {
        public virtual void Say()
        {
            ("Anmial Say");
        }
        
    }

    class Dog : Anmial
    {
        public override void Say()
        {
            ("Dog Say");
        }
    }

    class Mouse : Anmial
    {

        public override void Say()
        {
            ("Mouse Say");
        }
    }






   class Cat:Anmial




     {






       //........没有重写方法的时候，调用的是父类的方法,(因为是继承了父类的方法)
     }

运行结果:
Anmial Say
Dog Say
Dog Say

2.抽象类的抽象方法实现多态

 class Program
    {
        static void Main(string[] args)
        {
            Anmial a1 = new Cat();
            Anmial d1 = new Dog();
           
            List<Anmial> list = new List<Anmial>();
            (a1);
            (d1);

            foreach (var a in list)
            {
                ();
            }
            ();
        }
    }
    /// <summary>
    /// 抽象类中只能声明，方法，属性，索引器,字段等，不能被实例化
    /// </summary>
    public abstract class Anmial
    {
        public void Fly()
        {
            ("飞");
        }
        public abstract void Say();//抽象方法，没有方法的实现体
    }

    class Cat:Anmial
    {

        public override void Say()
        {
            ("猫叫");
        }
    }

    class Dog : Anmial
    {
        public override void Say()
        {
            ("狗叫");
        }
    }

3.接口实现多态

class Program
    {
        static void Main(string[] args)
        {
            Anmial a1 = new Dog();
            Anmial c1 = new Cat();
            List<Anmial> list = new List<Anmial>();
            (a1);
            (c1);
            foreach(var a in list)
            {
                ();
            }
            ();
        }
    }
    interface Anmial
    {
        void Say();
    }

    class Dog : Anmial
    {
        #region Anmial 成员

        public void Say()
        {
            ("狗叫");
        }

        #endregion
    }

    class Cat : Anmial
    {
        #region Anmial 成员

        public void Say()
        {
            ("猫叫");
        }

        #endregion
    }

这三种方式实现多态有那些区别呢？

//接口多定义对象行为，抽象类定义对象属性