Liskov Substitution principle

source link:  http://www.cnblogs.com/liveordie/archive/2011/03/09/1979197.html

http://book.51cto.com/art/200912/166943.htm

 

 

Liskov替换原则：子类型必须能够替换它们的基类型

1. 如果每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换为o2时,程序P的行为没有变化，那么类型T2是类型T1的子类型。

2. 换言之，一个软件实体如果使用的是一个基类的话，那么一定适用于其子类，而且它根本不能察觉出基类对象和子类对象的区别。只有衍生类替换基类的同时软件实体的功能没有发生变化，基类才能真正被复用。

3. 里氏代换原则由Barbar Liskov(芭芭拉.里氏)提出，是继承复用的基石。

4. 一个继承是否符合里氏代换原则，可以判断该继承是否合理（是否隐藏有缺陷）。

 应当尽量从抽象类继承，而不从具体类继承。

　　一般而言,如果有两个具体类A、B有继承关系，那么一个最简单的修改方案是建立一个抽象类C，然后让类A和B成为抽象类C的子类。即如果有一个由继承关系形成的等级结构的话,那么在等级结构的树形图上面所有的树叶节点都应当是具体类，而所有的树枝节点都应当是抽象类或者接口。

 

里氏代换原则是由麻省理工学院（MIT）计算机科学实验室的Liskov女士，在1987年的OOPSLA大会上发表的一篇文章《Data Abstraction and Hierarchy》里面提出来的，主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中的蕴涵的原理。2002年，软件工程大师Robert C. Martin，出版了一本《Agile Software Development Principles Patterns and Practices》，在文中他把里氏代换原则最终简化为一句话："Subtypes must be substitutable for their base types"，也就是说，子类必须能够替换成它们的基类。

我们把里氏代换原则解释得更完整一些：在一个软件系统中，子类应该可以替换任何基类能够出现的地方，并且经过替换以后，代码还能正常工作。子类也能够在基类的基础上增加新的行为。

里氏代换原则是对开闭原则的补充，它讲的是基类和子类的关系。只有当这种关系存在时，里氏代换关系才存在。

"正方形是长方形"是一个理解里氏代换原则的最经典的例子。在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，应该让正方形继承自长方形。

1. package principle.liskovsubstitution;  
2.  
3. public class Rectangle {  
4.     private int height;   
5.     private int width;  
6.  
7.     public int getHeight() {  
8.         return height;  
9.     }  
10.  
11.     public void setHeight(int height) {  
12.         this.height = height;  
13.     }  
14.  
15.     public int getWidth() {  
16.         return width;  
17.     }  
18.  
19.     public void setWidth(int width) {  
20.         this.width = width;  
21.     }  
22. } 

继承了长方形的正方形类如程序1-2所示。

程序1-2  正方形类Square.java

1. package principle.liskovsubstitution;  
2.  
3. public class Square extends Rectangle {  
4.     public void setWidth(int width) {  
5.         super.setWidth(width);  
6.         super.setHeight(width);  
7.     }  
8.     public void setHeight(int height) {  
9.         super.setWidth(height);  
10.         super.setHeight(height);  
11.     }  
12. } 

由于正方形的长度和宽度必须相等，所以在方法setLength()和setWidth()中，对长度和宽度赋值相同。程序1-3所示的测试类中的函数zoom()用来增加长方形的长和宽。

程序1-3  测试类TestRectangle.java

1. package principle.liskovsubstitution;  
2.  
3. public class TestRectangle {  
4.     public void zoom(Rectangle rectangle, int width, int height) {  
5.         rectangle.setWidth(rectangle.getWidth() + width);  
6.         rectangle.setHeight(rectangle.getHeight() + height);  
7.     }  
8. } 

显然，当增加的长度和宽度不同时，不能够将其中的长方形换成其子类正方形。这就违反了里氏代换原则。

 

为了符合里氏代换原则，我们可以为长方形和正方形创建一个父类Base，并在其中定义好共有的属性，并定义一个zoom()抽象函数，如程序1-4所示。

程序1-4  父类Base.java

1. package principle.liskovsubstitution;  
2.  
3. public abstract class Base {  
4.     private int height;  
5.     private int width;  
6.  
7.     public int getHeight() {  
8.         return height;  
9.     }  
10.  
11.     public void setHeight(int height) {  
12.         this.height = height;  
13.     }  
14.  
15.     public int getWidth() {  
16.         return width;  
17.     }  
18.  
19.     public void setWidth(int width) {  
20.         this.width = width;  
21.     }  
22.  
23.     public abstract void zoom(int width, int height);  
24. } 

长方形类继承自该父类，并编写自己的zoom()实现函数，如程序1-5所示。

程序1-5  修改后的长方形类BaseRectangle.java

1. package principle.liskovsubstitution;  
2.  
3. public class BaseRectangle extends Base {  
4.     public void zoom(int width, int height) {  
5.         setWidth(getWidth() + width);  
6.         setHeight(getHeight() + height);  
7.     }  
8. } 

正方形类也继承自该父类，并编写自己的zoom()实现函数，如程序1-6所示。

程序1-6  修改后的正方形类BaseSquare.java

1. package principle.liskovsubstitution;  
2.  
3. public class BaseSquare extends Base {  
4.     public void setWidth(int width) {  
5.         super.setWidth(width);  
6.         super.setHeight(width);  
7.     }  
8.     public void setHeight(int height) {  
9.         super.setWidth(height);  
10.         super.setHeight(height);  
11.     }  
12.       
13.     public void zoom(int width, int height) {  
14.         int length = (width + height) /2;  
15.         setWidth(getWidth() + length);  
16.         setHeight(getHeight() + length);  
17.     }  
18. } 

编写测试函数如程序1-7所示。

程序1-7  修改后的测试类BastTest.java

1. package principle.liskovsubstitution;  
2.  
3. public class BastTest {  
4.     public void zoom(Base base, int width, int height) {  
5.         base.zoom(width, height);  
6.     }  
7. } 

此时的Base类可以被它的子类Rectangle和Square所替代，而不用改变测试代码。这就是符合里氏代换原则的编写方式。

由此可见，在进行设计的时候，我们尽量从抽象类继承，而不是从具体类继承。如果从继承等级树来看，所有叶子节点应当是具体类，而所有的树枝节点应当是抽象类或者接口。当然这只是一个一般性的指导原则，使用的时候还要具体情况具体分析。