面向对象设计（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()
{
CSquares;
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;
};