定义
In a computer program, if S is a subtype of T, then objects of type T may be replaced with objects of type S (i.e. an object of type T may be substituted with any object of a subtype S) without altering any of the desirable properties of the program (correctness, task performed, etc.)
即:所有引用基类的地方必须能透明地使用其子类的对象,也就是说子类对象可以替换其父类对象,而程序执行效果不变。
定义的解读
在继承体系中,子类中可以增加自己特有的方法,也可以实现父类的抽象方法,但是不能重写父类的非抽象方法,否则该继承关系就不是一个正确的继承关系。
优点
可以检验继承使用的正确性,约束继承在使用上的泛滥。
代码讲解
在这里用一个简单的长方形与正方形的例子讲解一下里氏替换原则。
需求点
创建两个类:长方形和正方形,都可以设置宽高(边长),也可以输出面积大小。
不好的设计
首先声明一个长方形类,然后让正方形类继承于长方形。
长方形类:
//================== Rectangle.h ==================
@interface Rectangle : NSObject
{
@protected double _width;
@protected double _height;
}
//设置宽高
- (void)setWidth:(double)width;
- (void)setHeight:(double)height;
//获取宽高
- (double)width;
- (double)height;
//获取面积
- (double)getArea;
@end
//================== Rectangle.m ==================
@implementation Rectangle
- (void)setWidth:(double)width{
_width = width;
}
- (void)setHeight:(double)height{
_height = height;
}
- (double)width{
return _width;
}
- (double)height{
return _height;
}
- (double)getArea{
return _width * _height;
}
@end
正方形类:
//================== Square.h ==================
@interface Square : Rectangle
@end
//================== Square.m ==================
@implementation Square
- (void)setWidth:(double)width{
_width = width;
_height = width;
}
- (void)setHeight:(double)height{
_width = height;
_height = height;
}
@end
可以看到,正方形类继承了长方形类以后,为了保证边长永远是相等的,特意在两个set方法里面强制将宽和高都设置为传入的值,也就是重写了父类Rectangle
的两个set方法。但是里氏替换原则里规定,子类不能重写父类的方法,所以上面的设计是违反该原则的。
而且里氏替换原则原则里面所属:子类对象能够替换父类对象,而程序执行效果不变。我们通过一个例子来看一下上面的设计是否符合:
在客户端类写一个方法:传入一个Rectangle
类型并返回它的面积:
- (double)calculateAreaOfRect:(Rectangle *)rect{
return rect.getArea;
}
我们先用Rectangle
对象试一下:
Rectangle *rect = [[Rectangle alloc] init];
rect.width = 10;
rect.height = 20;
double rectArea = [self calculateAreaOfRect:rect];//output:200
长宽分别设置为10,20以后,结果输出200,没有问题。
现在我们使用Rectange
的子类Square
的对象替换原来的Rectange
对象,看一下结果如何:
Square *square = [[Square alloc] init];
square.width = 10;
square.height = 20;
double squareArea = [self calculateAreaOfRect:square];//output:400
结果输出为400,结果不一致,再次说明了上述设计不符合里氏替换原则,因为子类的对象square
替换父类的对象rect
以后,程序执行的结果变了。
不符合里氏替换原则就说明该继承关系不是正确的继承关系,也就是说正方形类不能继承于长方形类,程序需要重新设计。
我们现在看一下比较好的设计。
较好的设计
既然正方形不能继承于长方形,那么是否可以让二者都继承于其他的父类呢?答案是可以的。
既然要继承于其他的父类,它们这个父类肯定具备这两种形状共同的特点:有4个边。那么我们就定义一个四边形的类:Quadrangle
。
//================== Quadrangle.h ==================
@interface Quadrangle : NSObject
{
@protected double _width;
@protected double _height;
}
- (void)setWidth:(double)width;
- (void)setHeight:(double)height;
- (double)width;
- (double)height;
- (double)getArea;
@end
接着,让Rectangle
类和Square
类继承于它:
Rectangle
类:
//================== Rectangle.h ==================
#import "Quadrangle.h"
@interface Rectangle : Quadrangle
@end
//================== Rectangle.m ==================
@implementation Rectangle
- (void)setWidth:(double)width{
_width = width;
}
- (void)setHeight:(double)height{
_height = height;
}
- (double)width{
return _width;
}
- (double)height{
return _height;
}
- (double)getArea{
return _width * _height;
}
@end
Square
类:
//================== Square.h ==================
@interface Square : Quadrangle
{
@protected double _sideLength;
}
-(void)setSideLength:(double)sideLength;
-(double)sideLength;
@end
//================== Square.m ==================
@implementation Square
-(void)setSideLength:(double)sideLength{
_sideLength = sideLength;
}
-(double)sideLength{
return _sideLength;
}
- (void)setWidth:(double)width{
_sideLength = width;
}
- (void)setHeight:(double)height{
_sideLength = height;
}
- (double)width{
return _sideLength;
}
- (double)height{
return _sideLength;
}
- (double)getArea{
return _sideLength * _sideLength;
}
@end
我们可以看到,Rectange
和Square
类都以自己的方式实现了父类Quadrangle
的公共方法。而且由于Square
的特殊性,它也声明了自己独有的成员变量_sideLength
以及其对应的公共方法。
注意,这里
Rectange
和Square
并不是重写了其父类的公共方法,而是实现了其抽象方法。
下面来看一下这两个设计的UML 类图,可以更形象地看出两种设计上的区别:
UML 类图对比
未实践里氏替换原则:
实践了里氏替换原则:
如何实践
里氏替换原则是对继承关系的一种检验:检验是否真正符合继承关系,以避免继承的滥用。因此,在使用继承之前,需要反复思考和确认该继承关系是否正确,或者当前的继承体系是否还可以支持后续的需求变更,如果无法支持,则需要及时重构,采用更好的方式来设计程序。