第2章面向对象的设计原则（SOLID）：2_里氏替换原则（LSP）

#include 

//长方形类
class Rectangle
{
protected:
    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;}
    
    long getArea(){return width * height;}
};

//正方形类(如果继承自长方形类)
class Square : public Rectangle
{
public:
    void setWidth(long width)
    {
        this->width = width;
        this->height = width;
    }
    
    long getWidth(){return this->width;}
    
    void setHeight(long height)
    {
        this->width = height;
        this->height = height;       
    }
    
    long getHeight(){return this->height;}      
};

int main()
{
    //LSP原则：父类出现的地方必须能用子类替换
    Rectangle* r = new Rectangle();//Square *r = new Square();
    
    r->setWidth(5);
    r->setHeight(4);
    
    printf("Area = %d\n",r->getArea()); //当用子类时，结果是16。用户就不
                                       //明白为什么长5，宽4的结果不是20，而是16.
                                       //所以正方形不能代替长方形。即正方形不能
                                       //继承自长方形的子类
    return 0;
}

#include 

//抽象的四方形类
class QuadRangle
{   
public:
    //将四方形抽象出公共部分出来
    virtual long getArea() = 0;     //面积
    virtual long getPerimeter() = 0;//周长
};

//长方形类(继承自抽象的四方形类)
class Rectangle : public QuadRangle
{
private:
    long width;
    long height;
public:
    Rectangle(long width, long heigth)
    {
        this->width = width;
        this->height = heigth;
    }
    
    void setWidth(long width){this->width = width;}
    long getWidth(){return this->width;}
    
    void setHeight(long height){this->height = height;}
    long getHeight(){return this->height;}
    
    long getArea(){return width * height;}
    long getPerimeter(){return (width + height) * 2;}
};

//正方形类(继承自抽象的四方形类)
class Square : public QuadRangle
{
    long side;
public:
    Square(long side) {this->side = side;}
    
    void setSide(long side);
    long getSide(){return this->side;}
    long getPerimeter(){return 4 * side;}
    long getArea(){return side * side;}
};

int main()
{
    //LSP原则：父类出现的地方必须能用子类替换
    QuadRangle* q = new Rectangle(5, 4); //Rectangle* q = new Rectangle(5, 4);或Square *q = new Square(5);
       
    printf("Area = %d, Perimeter = %d\n",q->getArea(), q->getPerimeter()); 
    
    return 0;
}

//面向对象设计原则：LSP里氏替换原则
//鸵鸟不是鸟的测试程序

#include 

//鸟类
class Bird
{
private:
    double velocity; //速度
public:
    virtual void fly() {printf("I can fly!\n");}
    virtual void setVelocity(double v){velocity = v;}
    virtual double getVelocity(){return velocity;}
};

//鸵鸟类Ostrich
class Ostrich : public Bird
{
public:
    void fly(){printf("I can\'t fly!");}
    void setVelocity(double v){Bird::setVelocity(0);}
    double getVelocity(){return Bird::getVelocity();}
};

//测试函数
void calcFlyTime(Bird& bird)
{
    try
    {
        double riverWidth = 3000;
            
        if(bird.getVelocity()==0) throw 0;
            
        printf("Velocity = %f\n", bird.getVelocity());
        printf("Fly time = %f\n", riverWidth /bird.getVelocity());
    }
    catch(int)
    {
        printf("An error occured!") ; 
    }
}

int main()
{
    //遵守LSP原则时，父类对象出现的地方，可用子类替换
    Bird b; //用子类Ostrich替换Bird
    
    b.setVelocity(100);
    
    calcFlyTime(b); //父类测试时是正常的，子类时会抛出异常，违反LSP
    
    return 0;
}

#include 

class Shape
{  
};

class Rectangle : public Shape
{
    
};

class Father
{
public:
    virtual void drawShape(Shape s) //
    {
        printf("Father:drawShape(Shape s)\n");
    }
    
    virtual void showShape(Rectangle r) //
    {
        printf("Father:ShowShape(Rectangle r)\n");       
    }
    
    Shape CreateShape()
    {
        Shape s;
        printf("Father: Shape CreateShape()");
        return s;
    }
};

class Son : public Father
{
public:

    //对于C++而言，重载只能发生在同一作用域。显示Son和Father是不同作用域
    //所以，下面发生的是隐藏，而不是重载！因此，当使用子类时，不管下列
    //函数中的形参是否比父类更严格，只要同名，父类virtual一律被隐藏。

    //子类的形参类型比父类更严格
    virtual void drawShape(Rectangle r)  
    {
        printf("Son:drawShape(Rectangle r)\n");        
    } 
    
    //子类的形参类型比父类严宽松
    virtual void showShape(Shape s)
    {
        printf("Son:showShape(Shape s)\n");        
    }   

    //返回值类型比父类严格
    Rectangle CreateShape()
    {
        Rectangle r;
        printf("Son: Rectangle CreateShape()");
        
        return r;
    } 
};

int main()
{
    //当遵循LSP原则时，使用父类地方都可以用子类替换

    //Father* f = new Father(); //该行可用子类替换    
    Son* f = new Son(); //用子类替换父类出现的地方

    Rectangle r;
    
    //子类形参类型更严格时，下一行输出结果会发生变化，不符合LSP原则
    f->drawShape(r); //Father类型的f时，调用父类的drawShape(Shape s)
                     //Son类型的f时，发生隐藏，会匹配子类的drawShape
    
    //子类形参类型更宽松时，对于C++而言，会因发生隐藏而不符合LSP原则。但Java发生重载，会符合LSP
    f->showShape(r); //Father类型的f时，直接匹配父类的showShape(Rectangle r)
                     //Son类型的f时，因发生隐藏，会匹配子类的showShape(Shape s)
                  
    //子类的返回值类型更严格
    Shape s = f->CreateShape(); //替换为子类时，返回值为Rectangle，比Shape类型小，这种赋值是合法的
    
    delete f;
    
    return 0;
}