软件设计原则----LisKov替换原则（LSP）

just_person 2012-06-07

展开全文

“一个软件实体如果使用的是一个基类的话，一定适用于其子类，而且根本不能觉察出基类对象和子类对象的区别。”

陈述：

子类型（Subtype）必须能够替换他们的基类型(Basetype)

Barbara Liskov对原则的陈述：

若对每个类型S的对象o1,都存在一个类型T的对象o2，使得在所有针对T编写的程序P中，用o1替换o2后，程序P的行为功能不变，则S是T的子类型。

通俗地讲，就是子类型能够完全替换父类型，而不会让调用父类型的客户程序从行为上有任何改变。

意义：

我们在客户程序在调用某一个类时，实际上是对该类的整个继承体系设定了一套约束，继承体系中的所有类必须遵循这一约束，即前置条件和后置条件必须保持一致。这为对象继承加上了一把严格的枷锁。显然，LSP原则对于约束继承的泛滥具有重要意义。

分析：

违反这个职责将导致程序的脆弱性和对OCP的违反

例如：基类Base，派生类Derived，派生类实例d,函数f(Base* p);

f(&d) 会导致错误

显然D对于f是脆弱的。

如果我们试图编写一些测试，以保证把d传给f时可以使f具有正确的行为。那么这个测试违反了OCP——因为f无法对Base的所有派生类都是封闭的。

经典例子：长方形与正方形驳论

[cpp]view plaincopyprint?
class Rectangle  
{  
private:  
     long width;  
     long height;  
public:  
    void setWidth(long width)  
    {  
        this->width = width;  
    }  
    long getWidth()  
    {  
        return this->width;  
    }  
    void setHeight(long height)  
    {  
        this->height = height;  
    }  
    long getHeight()  
    {  
        return this->height;  
    }  
};  
  
//正方形类  
class Square  
{  
private:  
    long side;  
      
public:  
    void setSide(long side)  
    {  
        this->side = side;  
    }  
    long getSide()  
    {  
        return side;  
    }  
};  

[cpp]view plaincopyprint?
//正方形类（如果继承自长方形类）：  
class Square : public Rectangle  
{  
private:  
    long side;  
public:  
    void setWidth(long width)  
    {  
        setSide(width);  
    }  
    long getWidth()  
    {  
        return getSide();  
    }  
    void setHeight(long height)  
    {  
        setSide(height);  
    }  
    long getHeight()  
    {  
        return getSide();  
    }  
    long getSide()  
    {  
        return side;  
    }  
    void setSide(long side)  
    {  
        this->side = side;  
    }  
};  

[cpp]view plaincopyprint?
class SmartTest  
{  
public:  
    void resize(Rectangle r)  
    {  
    while (r.getHeight() <= r.getWidth() )  
        {  
        r.setWidth(r.getWidth() + 1);  
        }  
    }  
};  

从上面小函数可见，只想改变长方形的宽时，如果把正方形看成一种长方形的话，则正方形的长和宽都被改变了。LSP原则被破坏了，Square不应成为Rectangle的子类。

结论：
里氏代换与通常的数学法则和生活常识有不可混淆的区别。
考虑一个设计是否恰当时，不能孤立的看待并判断，应该从此设计的使用者所作出的假设来审视它！

思考：
这个看似明显正确的模型怎么会出错呢？
“正方形是一种长方形”
对不是SmartTest函数的编写者而言，正方形可以是长方形，但是对SmartTest函数的编写者而言，Square绝对不是Rectangle！！

OOD中对象之间是否存在IS-A关系，应该从行为的角度来看待。

->而行为可以依赖客户程序做出合理的假设。

改进：

引入一个Quadrangle（四边形）类，并将Rectangle 与Square变成它的具体子类，解决了Rectangle 与Square的关系不符合里氏替换原则的问题。

[cpp]view plaincopyprint?
class Quadrangle  
{  
public:  
    virtual long getWidth() = 0;      
    virtual long getHeight() = 0;  
};  

Quadrangle类只声明两个取值方法，不声明任何的赋值方法。

//长方形类：

[cpp]view plaincopyprint?
class Rectangle : public Quadrangle   
{  
private:  
    long width;  
    long height;  
      
public:  
    void setWidth(long width)  
    {  
        this->width = width;  
    }  
    long getWidth()  
    {  
        return this->width;  
    }  
    void setHeight(long height)  
    {  
        this->height = height;  
    }  
    long getHeight()  
    {  
        return this->height;  
    }  
};  

//正方形类：

[cpp]view plaincopyprint?
class Square : public Quadrangle   
{  
private:  
    long side;  
      
public:  
    void setSide(long side)  
    {  
        this->side = side;  
    }  
      
    long getSide()  
    {  
        return side;  
    }  
      
    long getWidth()  
    {  
        return getSide();  
    }  
      
    long getHeight()  
    {  
        return getSide();  
    }  
};  