面向对象设计（OOD）中的替换原则

最新推荐文章于 2023-02-07 16:09:08 发布

StarLee

最新推荐文章于 2023-02-07 16:09:08 发布

阅读量4.9k

点赞数

分类专栏：面向对象设计 Windows下C++编程文章标签： class c++ 语言工作

本文链接：https://blog.csdn.net/starlee/article/details/945728

版权

Windows下C++编程同时被 2 个专栏收录

48 篇文章 92 订阅

订阅专栏

面向对象设计

2 篇文章 0 订阅

订阅专栏

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

现在，我们需要一个正方形类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;
};