面向对象设计原则

原则	解释
单一职责原则	类的指责单一，对外只提供一种功能
开闭原则	类的改动时通过增加代码进行的，而不是修改源代码
里氏代换原则	多态，任何抽象类出现的地方都可以用他的实现类进行替换
依赖倒转原则	依赖于抽象（接口），不要依赖具体的实现类，也就是针对接口编程
接口隔离原则	一个接口应该只提供一种对外功能
合成复用原则	如果使用继承，会导致父类的任何变化都可能影响到子类的行为，对于继承和组合，尽量使用组合
迪米特法则	一个对象应该对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提供系统可维护性

开闭原则

对扩展开放，对修改关闭


//计算器抽象类
class AbstractCalculator{
public:
    virtual void setOperator() = 0;
    virtual int getResult() = 0;
};

//加法计算器类
class PlusCaculator : public AbstractCaculator{
    public:
        virtual void setOperatorNumber(int a, int b){
            this->m_a = a;
            this->m_b = b;
        }
        virtual int getResult(){
            return m_a + m_b;
        }
}

//减法计算器类
class MinusCaculator : public AbstractCaculator{
    public:
        virtual void setOperatorNumber(int a, int b){
            this->m_a = a;
            this->m_b = b;
        }
        virtual int getResult(){
            return m_a - m_b;
        }
};
//乘法
class MulCaculator : public AbstractCaculator{
    public:
        virtual void setOperatorNumber(int a, int b){
            this->m_a = a;
            this->m_b = b;
        }
        virtual int getResult(){
            return m_a *+* m_b;
        }
};

class DivCaculator : public AbstractCaculator{
    public:
        virtual void setOperatorNumber(int a, int b){
            this->m_a = a;
            this->m_b = b;
        }
        virtual int getResult(){
            return m_a / m_b;
        }
}

void test(){
    AbstractCaculator * caculator = new PlusCaculator;
    caculator->setOperatorNumber(10, 20);
    cout<<caculator->getResult<<endl;

    caculator = new MinusCaculator;
    caculator->setOperatorNumber(10, 20);
    cout<<caculator->getResult<<endl;
}

迪米特法则

知道的越少，建立的耦合关系就越弱


class AbstractBuilding{
    public:
        virtual void sale() = 0;
        virtual string getQuality() = 0;
};


class BuildingA : public AbstractBuilding{
    public : 
        BuildingA(){
            mQuality = "高品质";
        }
        virtual void sale(){
            cout<< mQuality <<endl;
        }
        string getQuality(){
            return mQuality;
        }
    private:
        string mQuality;
};


class BuildingB : public AbstractBuilding{
    public : 
        BuildingA(){
            mQuality = "中品质";
        }
        virtual void sale(){
            cout<< mQuality <<endl;
        }
        string getQuality(){
            return mQuality;
        }
    private:
        string mQuality;
};

class BuildingC : public AbstractBuilding{
    public : 
        BuildingC(){
            mQuality = "低品质";
        }
        virtual void sale(){
            cout<< mQuality <<endl;
        }
        string getQuality(){
            return mQuality;
        }
    private:
        string mQuality;
};

//中介类
class Media{
    public:
        Media(){

        }
        AbstractBuilding* findMyBuilding(string quality){
            for(auto building : vBuilding){
                if(building->getQuality == quality){
                    return building ;
                }
            }
            return NULL;
        }

        ~Media(){
            for(auto building : vBuilding){
                delete building;
            }
        }
        vector<AbstractBuilding*> vBuilding;    
}

void test(){
    Media* media = new Media;
    AbstractBuilding* building = media->findMyBuilding("高品质");
    if(building != NULL){
        build->sale();
    }else{
        cout<<"No suitable"<<endl;
    }
}

Deep Zheng

郑璟泓

面向对象设计原则

面向对象设计原则

开闭原则

迪米特法则