02-里氏替换原则(LSP)

1. 背景

有一个功能p1,由类A完成，现在需要将功能p1进行扩展，扩展后的功能为p3，p3由原功能p1和新功能p2组成，而新功能p3和p2均由类A的子类B来完成，子类B在完成新功能p2的同时，可能会导致原有的功能p1故障。

2. 定义

    所有引用基类的地方能透明的使用其子类对象进行替代。

3. 对应的解决方案

　 使用继承时，父类已经实现好了的方法(非抽象方法),实际上是有一系列规范和契约的，虽然不强制子类必须遵循，但如果子类对这些非抽象方法进行重写、重载后，会造成整个继承体系被破坏。而里氏替换原则也正是表达了这层含义。

4. 补充对继承的理解

　  继承作为面向对象三大特性之一，在给程序设计带来巨大便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加了对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能会产生故障。

5.  案例

    需求一：完成两个数相减的功能，由类A完成。

  public class A
     {
         /// <summary>
         /// 两数相加
         /// </summary>
         /// <param name="a"></param>
         /// <param name="b"></param>
         /// <returns></returns>
         public int func1(int a, int b)
         {
             return a - b;
         }
         /// <summary>
         /// 两数相乘
         /// </summary>
         /// <param name="a"></param>
         /// <param name="b"></param>
         /// <returns></returns>
         public int func3(int a, int b)
         {
             return a * b;
         }
     }

需求二：完成两个数相加，然后再加100的功能，由类A的子类类B完成。

   public class B:A
     {
         public int func1(int a, int b)
         {
             return a + b;
         }
         public int func2(int a, int b)
         {
             return func1(a, b) + ;
         }
     }

　下面我们对上述写的代码进行测试。

(1). 用类A测试两个数相减，如：100-50

(2). 用类B测试两个数相减(因为类B继承了类A)，如：100-50

(3). 用类B测试两个数相加后再加100的功能，如：100+50+100

         public static void show()
         {
             //需求1：完成两个数相减的功能，由类A来完成
             A a = new A();
             Console.WriteLine("100-50={0}", a.func1(, ));   //50

             //需求2：完成两个数相加功能，然后再加100，由类A的子类B来完成
             B b = new B();
             Console.WriteLine("100-50={0}", b.func1(, ));   //150,因为子类重写了fun1，则隐藏了父类中fun1原有的方法 (错误)
             Console.WriteLine("100和50相加，然后再减掉100，结果为：{0}", b.func2(, ));   //

         }

　结果：

 我们会发现， 用类B测试两个数相减的功能出错了，竟然变成两数相加的功能了，原因是类B中声明了和其父类相同的方法名的方法，即隐藏了父类原有的方法，违背了里氏替换原则。

6. 里氏替换原则的深刻理解

　子类可以扩展父类没有的功能，但是不能改变父类的功能

a：子类可以实现父类的抽象方法，但不能重写父类的非抽象方法。

b：子类可以增加自己特有的方法。

c：子类重载父类方法时，其方法的形参要比父类方法的形参更宽松。

d：子类实现父类抽象方法时，其方法的返回值要比父类方法的更严格。

7. 正宗的里氏替换原则的用法

        public static void show()
        {

            A aa = new B();
            Console.WriteLine("100*50={0}",aa.func3(, ));   //5000   正宗的里氏替换原则
            //Console.WriteLine(aa.func2(100, 50));   //代码报错，父类不能调用子类扩展的方法
        }

8. 违背里氏替换原则的后果

　出错率会增高