设计原则（二）里氏替换原则（LSP）
一、什么是里氏替换原则
里氏替换原则的严格表达是：
如果对每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有变化，那么类型T2是类型T1的子类型。
换言之，一个软件实体如果使用的是一个基类的话，那么一定适用于其子类，而且它根本不能察觉出基类对象和子类对象的区别。
比如，假设有两个类，一个是Base类，另一个是Child类，并且Child类是Base的子类。那么一个方法如果可以接受一个基类对象b的话:method1(Base b)那么它必然可以接受一个子类的对象method1(Child c).
里氏替换原则是继承复用的基石。只有当衍生类可以替换掉基类，软件单位的功能不会受到影响时，基类才能真正的被复用，而衍生类也才能够在基类的基础上增加新的行为。
但是需要注意的是，反过来的代换是不能成立的，如果一个软件实体使用的是一个子类的话，那么它不一定适用于基类。如果一个方法method2接受子类对象为参数的话method2(Child c)，那么一般而言不可以有method2(b).
二、墨子的智慧
《墨子:小取》中说，“白马，马也；乘白马，乘马也。骊马，马也；乘骊马，乘马也”。文中的骊马是黑的马。意思就是白马和黑马都是马，乘白马或者乘黑马就是乘马。在面向对象中我们可以这样理解，马是一个父类，白马和黑马都是马的子类，我们说乘马是没有问题的，那么我们把父类换成具体的子类，也就是乘白马和乘黑马也是没有问题的，这就是我们上边说的里氏替换原则。
墨子同时还指出了反过来是不能成立的。《墨子:小取》中说：“娣，美人也，爱娣，非爱美人也”。娣是指妹妹，也就是说我的妹妹是没人，我爱我的妹妹（出于兄妹感情），但是不等于我爱美人。在面向对象里就是，美人是一个父类，妹妹是美人的一个子类。哥哥作为一个类有“喜爱（）”方法，可以接受妹妹作为参量。那么这个“喜爱（）”不能接受美人类的实例，这也就说明了反过来是不能成立的。
三、正方形是不是长方形
上过数学课的人都知道，正方形是一种特殊的长方形，只不过是它的长和宽是一样的，也就是说我们在面向对象里我们应当将长方形设计成父类，将正方形设计成长方形的子类，但是我可以很负责的告诉你，这样做是错误的，是不符合里氏替换原则的。
package com.designphilsophy.lsp.version1;
/**
* 定义一个长方形类，只有标准的get和set方法
*
* @author xingjiarong
*
*/
public class Rectangle {
protected long width;
protected long height;
public void setWidth(long width) {
this.width = width;
}
public long getWidth() {
return this.width;
}
public void setHeight(long height) {
this.height = height;
}
public long getHeight() {
return this.height;
}
}
package com.designphilsophy.lsp.version1;
/**
* 定义一个正方形类继承自长方形类，只有一个side
*
* @author xingjiarong
*
*/
public class Square extends Rectangle {
public void setWidth(long width) {
this.height = width;
this.width = width;
}
public long getWidth() {
return width;
}
public void setHeight(long height) {
this.height = height;
this.width = height;
}
public long getHeight() {
return height;
}
}package com.designphilsophy.lsp.version1;
public class SmartTest
{
/**
* 长方形的长不短的增加直到超过宽
* @param r
*/
public void resize(Rectangle r)
{
while (r.getHeight() <= r.getWidth() )
{
r.setHeight(r.getHeight() + 1);
}
}
}
问题由来：有一功能P1，由类A完成。现需要将功能P1进行扩展，扩展后的功能为P，其中P由原有功能P1与新功能P2组成。新功能P由类A的子类B来完成，则子类B在完成新功能P2的同时，有可能会导致原有功能P1发生故障。
解决方案：当使用继承时，遵循里氏替换原则。类B继承类A时，除添加新的方法完成新增功能P2外，尽量不要重写父类A的方法，也尽量不要重载父类A的方法。
刚才我们写的代码的结构就是上边那样的，对于这样不符合里氏替换原则原则的关系，我们在代码重构的时候一般采用下面的方法。
我们再定义一个他们共同的父类，然后让正方形和长方形都继承自这个父类。
具体的代码如下：
package com.designphilsophy.lsp.version2;
/**
* 定义一个四边形类，只有get方法没有set方法
* @author xingjiarong
*
*/
public abstract class Quadrangle {
protected abstract long getWidth();
protected abstract long getHeight();
}
package com.designphilsophy.lsp.version2;
/**
* 自己声明height和width
* @author xingjiarong
*
*/
public class Rectangle extends Quadrangle {
private long width;
private long height;
public void setWidth(long width) {
this.width = width;
}
public long getWidth() {
return this.width;
}
public void setHeight(long height) {
this.height = height;
}
public long getHeight() {
return this.height;
}
}
package com.designphilsophy.lsp.version2;
/**
* 自己声明height和width
* @author xingjiarong
*
*/
public class Square extends Quadrangle
{
private long width;
private long height;
public void setWidth(long width) {
this.height = width;
this.width = width;
}
public long getWidth() {
return width;
}
public void setHeight(long height) {
this.height = height;
this.width = height;
}
public long getHeight() {
return height;
}
}在基类Quadrange类中没有赋值方法，因此类似于SamrtTest的resize（）方法不可能适用于Quadrangle类型，而只能适用于不同的具体子类Rectangle和Aquare，因此里氏替换原则不可能被破坏了。
四、为什么要符合里氏替换原则
里氏替换原则通俗的来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。它包含以下4层含义：
- 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
- 子类中可以增加自己特有的方法。
- 当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
- 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。
看上去很不可思议，因为我们会发现在自己编程中常常会违反里氏替换原则，程序照样跑的好好的。所以大家都会产生这样的疑问，假如我非要不遵循里氏替换原则会有什么后果？来看一个例子。
package com.designphilsophy.lsp.version3;
public class A{
public int func1(int a, int b){
return a-b;
}
}
package com.designphilsophy.lsp.version3;
public class B extends A{
public int func1(int a, int b){
return a+b;
}
public int func2(int a, int b){
return func1(a,b)+100;
}
}
package com.designphilsophy.lsp.version3;
public class Client{
public static void main(String[] args){
B b = new B();
System.out.println("100-50="+b.func1(100, 50));
System.out.println("100-80="+b.func1(100, 80));
System.out.println("100+20+100="+b.func2(100, 20));
}
} 输入结果：
100-50=150
100-80=180
100+20+100=220
我们发现原本运行正常的相减功能发生了错误。原因就是类B在给方法起名时无意中重写了父类的方法，造成所有运行相减功能的代码全部调用了类B重写后的方法，造成原本运行正常的功能出现了错误。在本例中，引用基类A完成的功能，换成子类B之后，发生了异常。在实际编程中，我们常常会通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的几率非常大。
源码下载：http://download.csdn.net/detail/xingjiarong/9308063