面向对象七大设计原则之里氏替换原则

        熟练掌握和应用面向对象设计七大原则，是初中级工程师向高级/资深工程师进阶的一个必备技能。他可以大大的提升程序的可复用性和可维护性是重构代码的一大利器。

        本人菜鸟一枚本面文章的出发点是1.加深个人印象。2.作为笔记记录。3.分享。文章中有描述的不到位或者不正确的地方各位大佬多多指出多多包涵。

        使用设计模式的根本原因是适应变化，提升代码的复用率，扩展性，维护性和可读性。在设计时需要遵守以下七大原则：

        ⑴ 单一职责原则

        ⑵ 开放封闭原则

        ⑶ 依赖倒置原则

        ⑷ 里氏替换原则

        ⑸ 接口隔离原则

        ⑹ 组合复用原则

        ⑺ 迪米特原则

里氏替换原则

        指的是子类必须更够替换掉父类，在开发过程中，子类替换掉父类之后，程序能够正常运行并且结果正确，行为正确。只有当子类替换掉父类之后，此时程序功能不受影响，父类才能够真正的被复用，而子类此时就可以在父类的基础上添加新的行为。

        子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除了添加新的方法完成新增功能外，尽量不要重写父类的方法。

    class Program
    {
        static void Main(string[] agrs)
        {
            Dog redDog = new RedDog();
            Dog yellowDog = new YellowDog();
            Console.WriteLine("redDog:" + redDog.typeStr);
            Console.WriteLine("yellowDog:" + yellowDog.typeStr);

            Console.Read();
        }
    }

    class Dog
    {
        public string typeStr
        {
            get
            {
                return "基类";
            }
        }
    }

    class RedDog : Dog
    {
        public string typeStr
        {
            get
            {
                return "派生类RedDog";
            }
        }
    }

    class YellowDog : Dog
    {
        public string typeStr
        {
            get
            {
                return "派生类RedDog";
            }
        }
    }

运行结果如下：

        从上面的运行结果可以看出来，本来为RedDog和YellowDog类最后输出的竟然是父类的结果，这样一来就违背了里氏替换原则，必须保证只有当子类替换掉父类之后程序能够正常运行并且结果正确，行为正确。 修改代码如下：

    class Program
    {
        static void Main(string[] agrs)
        {
            IDog redDog = new RedDog();
            IDog yellowDog = new YellowDog();
            Console.WriteLine("redDog:" + redDog.typeStr);
            Console.WriteLine("yellowDog:" + yellowDog.typeStr);

            Console.Read();
        }
    }

    interface IDog
    {
        string typeStr { get; }
    }

    class RedDog : IDog
    {
        public string typeStr => "派生类RedDog";
    }

    class YellowDog : IDog
    {
        public string typeStr => "派生类RedDog";
    }

运行结果如下：

        我们可以使用继承接口的形式实现，父类替换掉子类后不能影响其子类的行为。还有一种情况是继承类的时候，代码如下：

    class Program
    {
        static void Main(string[] agrs)
        {
            RedDog redDog = new RedDog();
            YellowDog yellowDog = new YellowDog();
            Console.WriteLine("redDogName:" + redDog.dogName);
            Console.WriteLine("yellowDog:" + yellowDog.dogName);

            Console.WriteLine("redDog:" + redDog.typeStr);
            Console.WriteLine("yellowDog:" + yellowDog.typeStr);

            Console.Read();
        }
    }

    class Dog
    {
        public string typeStr { get { return "基类Dog"; } }
    }

    class RedDog : Dog
    {
        public string dogName => "派生类RedDog";
    }

    class YellowDog : Dog
    {
        public string dogName => "派生类YellowDog";
    }

运行结果如下：

可以看的出来子类既包含了父类，又完成了功能的扩展符合里氏替换原则。