设计模式6大原则-里氏替换原则

设计模式6大原则-里氏替换原则

定义1：如果每一个类型为S的对象o1,都有类型为T的对象o2，使得以T定义的所有程序P将所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。

定义2：所有引用基类的地方必须能透明地使用其子类的对象

优点：
(1) 代码共享，提高代码复用性，每个子类都拥有父类的方法和属性
(2) 提高代码的扩展性，子类可形似父类，但异于父类

缺点：
(1) 继承是侵入性的，只要继承就必须拥有父类的所有方法和属性，在一定程度上约束了子类，降低了代码的灵活性
(2) 增加了耦合，当父类的常量、变量或者方法被修改了，需要考虑子类的修改，所以一旦父类有了变动，很可能影响子类，需要重构大量的代码

里氏替换原则允许子类扩展父类的功能，但尽量不改变父类原有的功能(除非必要不要重写父类的方法)。
(1) 子类可以实现父类的抽象方法
(2) 子类可以增加自己的方法
(3) 当子类覆盖或实现父类的方法时，方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松
(4) 当子类的方法实现父类的抽象方法时，方法的后置条件(即方法的返回值)要比父类更严格

下面以实例展示如何使用子类替换父类，程序依然可以正常执行
动物饲养员负责饲养动物，动物需要呼吸，动物能移动，动物类作为抽象父类，具体动物类有多种(狗、猫、鸟、鱼、牛等)，饲养员只需要引用一个动物抽象类，调用动物抽象类方法，无论将哪个具体实现类添加给饲养员，都能正常运行

代码如下
动物抽象类

    // 动物基类
    public abstract class Animal
    {
        protected string _name;

        // 构造函数
        public Animal(string name)
        {
            _name = name;
        }

        // 呼吸,抽象方法,需要在子类中实现
        public abstract void Breathe();

        // 移动,虚方法,可以在子类中重写
        public virtual void Run()
        {
        }

        public string GetName()
        {
            return _name;
        }
    }

具体动物类：Cow(牛)、 Fish(鱼)

    // 牛：继承 Animal
    public class Cow : Animal
    {
        public Cow(string name) : base(name)
        {
        }

        // 呼吸,实现父类抽象方法
        public override void Breathe()
        {
            string msg = string.Format("{0}_用肺呼吸", _name);
            Console.WriteLine(msg);
        }

        // 移动,重写父类方法
        public override void Run()
        {
            string msg = string.Format("{0}_用腿走路 \n", _name);
            Console.WriteLine(msg);
        }
    }

    // 鱼
    public class Fish : Animal
    {
        public Fish(string name) : base(name)
        {
        }

        // 呼吸,实现父类抽象方法
        public override void Breathe()
        {
            string msg = string.Format("{0}_用鳃呼吸", _name);
            Console.WriteLine(msg);
        }

        // 移动,重写父类方法
        public override void Run()
        {
            string msg = string.Format("{0}_用尾巴游动 \n", _name);
            Console.WriteLine(msg);
        }
    }

饲养员类
饲养员引用一个抽象父类，调用抽象父类的方法，在运行时将不同的具体类对象赋值给饲养员，程序依然正确运行

    // 饲养员
    public class Breeder
    {
        private string _name;
        private Animal _animal;
        public Breeder(string name)
        {
            _name = name;
        }

        public void SetAnimal(Animal animal)
        {
            _animal = animal;
        }

        public void ShowAnimal()
        {
            string msg = string.Format("我是饲养员_{0},我养的动物是_{1}", _name, _animal.GetName());
            Console.WriteLine(msg);

            _animal.Breathe();
            _animal.Run();
        }
    }

调用如下

    public class Client
    {
        public Client()
        {
            Breeder breeder1 = new Breeder("张三");
            Cow cow = new Cow("牛");
            breeder1.SetAnimal(cow);
            breeder1.ShowAnimal();

            Breeder breeder2 = new Breeder("李四");
            Fish fish = new Fish("鱼");
            breeder2.SetAnimal(fish);
            breeder2.ShowAnimal();
        }
    }

运行结果如下