替换原则(LSP)--深度剖析--面向对象设计（OOD）

我们知道，在面向对象语言中，公有继承是IS-A的关系，也就是说子类是一种基类，就像说轿车是一种汽车一样。但是，有时候逻辑上正确的公有继承却会违反替换原则。面向对象设计中的替换原则是：
    子类必须能够替换掉它们的基类。
    也就是说，代码中基类出现的地方都能用子类来替换，就跟汽车能用的地方都能用轿车一样。但是，如果设计不合理，就会违反这个原则，给开发带来隐患。
    下面就以一个C++的例子来说明：

class  CShape
{
     public :
     virtual   ~ CShape() {};
     virtual   double  GetArea()  =   0 ;
};

class  CRectangle :  public  CShape
{
public :
     virtual   ~ CRectangle() {};
     double  GetArea() {  return  m_dWidth  *  m_dHeight; };
     void  SetWidth( double  dWidth) { m_dWidth  =  dWidth; };
     void  SetHeight( double  dHeight) { m_dHeight  =  dHeight; };
     double  GetWidth()  const  {  return  m_dWidth; };
     double  GetHeight()  const  {  return  m_dHeight; };

private :
     double  m_dWidth;
     double  m_dHeight;
};

    现在，我们需要一个正方形类CSquare。我们知道，正方形是一种宽和高相同的长方形，也就是说正方形和长方形符合IS-A的关系。那我们需要的类CSquare是否应该从类CRectangle来继承呢？
    我们现在先来看看类CSquare从类CRectangle继承的情况：

class  CSquare :  public  CRectangle
{
public :
     virtual   ~ CSquare() {};
     void  SetWidth( double  dWidth) 
    { 
        CRectangle::SetWidth(dWidth); 
        CRectangle::SetHeight(dWidth);
    };
     void  SetHeight( double  dHeight) 
    { 
        CRectangle::SetHeight(dHeight); 
        CRectangle::SetWidth(dHeight);
    };
};

    类CSquare中对方法SetWidth和方法SetHeight的重载解决了正方形的宽和高相等的问题。但是请考虑下面的代码：

void  FncTest(CRectangle &  r)
{
    r.SetWidth( 13 );
    assert(r.GetArea()  ==   169 );
}

void  Test()
{
    CSquare s;
    s.SetWidth( 5 );

    FncTest(s);
}

    当我们向函数FncTest传递一个指向类CSquare对象的引用的时候，这个函数就会出现断言错误，因为类CSquare对象的高度没有改变。这就违反了替换原则，函数FncTest中的类型为基类CRectangle的参数不能用子类CSquare来替换。错误原因很简单，类CRectangle中的方法SetWidth和方法SetHeight不是虚函数，因此不具备多态性。在这种情况下，我们就必须去修改类CRectangle。下面是修改后的代码：

class  CRectangle :  public  CShape
{
public :
     virtual   ~ CRectangle() {};
     double  GetArea() {  return  m_dWidth  *  m_dHeight; };
     virtual   void  SetWidth( double  dWidth) { m_dWidth  =  dWidth; };
     virtual   void  SetHeight( double  dHeight) { m_dHeight  =  dHeight; };
     double  GetWidth()  const  {  return  m_dWidth; };
     double  GetHeight()  const  {  return  m_dHeight; };

private :
     double  m_dWidth;
     double  m_dHeight;
};

class  CSquare :  public  CRectangle
{
public :
     virtual   ~ CSquare() {};
     virtual   void  SetWidth( double  dWidth) 
    { 
        CRectangle::SetWidth(dWidth); 
        CRectangle::SetHeight(dWidth);
    };
     virtual   void  SetHeight( double  dHeight) 
    { 
        CRectangle::SetHeight(dHeight); 
        CRectangle::SetWidth(dHeight);
    };
};

    这样，上面提到的问题就解决了，修改也不是很复杂。然而，如果派生类的创建会导致我们修改基类，这就意味着设计是有缺陷的。我们先不管是否有设计缺陷，而是先接受上面的修改。现在类CRectangle和类CSquare都能工作，在代码中也可以接受指向类CRectangle的指针或引用的函数传递类CSquare，而类CSquare也可以很好的保持正方形的特性。看起来，这样的设计已经符合替换原则了。但是，等等，请看下面的函数：

void  FncTest(CRectangle &  r)
{
    r.SetWidth( 5 );
    r.SetHeight( 6 );
    assert(r.GetArea()  ==   30 );
}

    对这个函数来说如果传递来的是类CRectangle的对象，则运行正确；如果传递来的是类CSque的对象，那就会出现断言错误！仍旧是违反了替换原则！
    上面的例子说明了，即使两个类是IS-A的关系，也不一定要用公有继承来实现。
    其实，在面向对象设计（OOD）中，IS-A关系是就行为方式而言的。在本例中，虽然类CRectangle和类CSquare在逻辑上是IS-A关系，但是他们的行为是不同的，因此也就不能让类CSquare从类CRectangle公有继承，而是从类CShape公有继承。
    下面是正确的代码：

class  CShape
{
public :
     virtual   ~ CShape() {};
     virtual   double  GetArea()  =   0 ;
};

class  CRectangle :  public  CShape
{
public :
     virtual   ~ CRectangle() {};
     double  GetArea() {  return  m_dWidth  *  m_dHeight; };
     void  SetWidth( double  dWidth) { m_dWidth  =  dWidth; };
     void  SetHeight( double  dHeight) { m_dHeight  =  dHeight; };
     double  GetWidth()  const  {  return  m_dWidth; };
     double  GetHeight()  const  {  return  m_dHeight; };

private :
     double  m_dWidth;
     double  m_dHeight;
};

class  CSquare :  public  CShape
{
public :
     virtual   ~ CSquare() {};
     double  GetArea() {  return  m_dWidth  *  m_dWidth; };
     void  SetWidth( double  dWidth) { m_dWidth  =  dWidth; };
     double  GetWidth()  const  {  return  m_dWidth; };

private :
     double  m_dWidth;
};