原文链接

Unity C# 多态委托事件匿名委托 Lambda表达式观察者模式 .NET 框架中的委托和事件 | Jason_c

原文写得很好，但是主题格式我不太喜欢，所以我对文章的格式进行了修整，方便自己日后阅读

正文

一、多态

里氏替换原则

任何能用基类的地方，可以用子类代替，反过来不行。子类能够在基类的基础上增加新的行为。面向对象设计的基本原则之一。

开放封闭原则

对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

关键是抽象，将一个功能的通用部分和实现细节部分清晰的分离开来。所有面向对象原则的核心。

实例

1. 虚方法实现多态

using System;

namespace Polymorphism
{
    // 鸟类：父类
    public class Bird
    {
        // 吃：虚方法
        public virtual void Eat()
        {
            Console.WriteLine("我是一只小小鸟，我喜欢吃虫子~");
        }
    }

    // 喜鹊：子类
    public  class Magpie:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只喜鹊，我喜欢吃虫子~");
        }
    }

    // 老鹰：子类
    public  class Eagle:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只老鹰，我喜欢吃肉~");
        }
    }

    // 企鹅：子类
    public  class Penguin:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只小企鹅，我喜欢吃鱼~");
        }
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            //创建一个Bird基类数组，添加基类Bird对象，Magpie对象，Eagle对象，Penguin对象
            Bird[] birds = {
                new Bird(),
                new Magpie(),
                new Eagle(),
                new Penguin()
            };
            //遍历一下birds数组
            foreach (Bird bird in birds)
            {
                bird.Eat();
            }
            Console.ReadKey();
        }
    }
}

运行结果

2. 抽象实现多态

using System;

namespace Polymorphism
{
    // 鸟类：父类
    public abstract class Bird
    {
        // 吃：虚方法
        public abstract void Eat();
    }

    // 喜鹊：子类
    public  class Magpie:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只喜鹊，我喜欢吃虫子~");
        }
    }

    // 老鹰：子类
    public  class Eagle:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只老鹰，我喜欢吃肉~");
        }
    }

    // 企鹅：子类
    public  class Penguin:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只小企鹅，我喜欢吃鱼~");
        }
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            //创建一个Bird基类数组，添加基类Bird对象，Magpie对象，Eagle对象，Penguin对象
            Bird[] birds = {
                new Magpie(),
                new Eagle(),
                new Penguin()
            };
            //遍历一下birds数组
            foreach (Bird bird in birds)
            {
                bird.Eat();
            }
            Console.ReadKey();
        }
    }
}

运行结果

3. 接口实现多态

using System;

namespace Polymorphism
{
    //飞
    public interface IFlyable
    {
        void Fly();
    }

    // 鸟类：父类
    public abstract class Bird
    {
        // 吃：虚方法
        public abstract void Eat();
    }

    // 喜鹊：子类
    public  class Magpie:Bird,IFlyable
    {
        public void Fly ()
        {
            Console.WriteLine ("我是一只喜鹊，我会飞~");
        }

        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只喜鹊，我喜欢吃虫子~");
        }
    }

    // 老鹰：子类
    public  class Eagle:Bird,IFlyable
    {
        public void Fly ()
        {
            Console.WriteLine ("我是一只老鹰，我可以飞~");
        }

        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只老鹰，我喜欢吃肉~");
        }
    }

    // 企鹅：子类
    public  class Penguin:Bird
    {
        // 重写父类中Eat方法
        public override void Eat()
        {
            Console.WriteLine("我是一只小企鹅，我喜欢吃鱼~");
        }
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            //创建一个Bird基类数组，添加基类Bird对象，Magpie对象，Eagle对象，Penguin对象
            Bird[] birds = {
                new Magpie(),
                new Eagle(),
                new Penguin()
            };
            //遍历一下birds数组
            foreach (Bird bird in birds)
            {
                bird.Eat();
            }

            Console.WriteLine ("-----------------------");

            //创建一个IFlyable接口数组，添加 Magpie对象，Eagle对象
            IFlyable[] flys = {
                new Magpie(),
                new Eagle()
            };
            //遍历一下flys数组
            foreach (IFlyable fly in flys)
            {
                fly.Fly();
            }
            Console.ReadKey();
        }
    }
}

运行结果：

【转载】Unity C# の 多态（一）