设计模式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();
        }
    }

运行结果如下
设计模式6大原则-里氏替换原则_第1张图片

你可能感兴趣的:(设计模式,里氏替换原则,里氏代换原则,设计模式6大原则)