设计模式--设计原则

黑马课程学习记录

目录

一、开闭原则

二、迪米特法则

 三、合成复用原则

四、依赖倒转原则

4.1 传统依赖方向

 4.2倒转原则

---

一、开闭原则

核心思想：开闭原则，对扩展开放，对修改关闭，增加功能是通过增加代码来实现，而不是去修改源代码

案例：实现一个计算器

 上面截图中直接将四个函数全部放在一个类中实现

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

//开闭原则，对扩展开放，对修改关闭，增加功能是通过增加代码来实现，而不是去修改源代码

//只要是修改代码了就会出错

//写一个抽象类
class AbstractCaculator {//单独传参数   单独获取结果，，，添加除法就只用添加代码  不用删除代码
public:
    virtual int getResult() = 0;
    virtual void setOperatorNumber(int a, int b) = 0;
};

//加法计算器
class PlusCalcultor :public AbstractCaculator {
public:
    virtual void setOperatorNumber(int a,int b) {
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult() {
        return mA + mB;
    }
public:
    int mA;
    int mB;
    //如果不用开闭原则的话这里可能还有结果参数、操作数参数，加减乘除全部放在一起
};

//减法计算器类
class MinuteCalcultor :public AbstractCaculator {
public:
    virtual void setOperatorNumber(int a, int b) {
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult() {
        return mA - mB;
    }
public:
    int mA;
    int mB;
};

//乘法计算器类
class MultiplyCalcultor :public AbstractCaculator {
public:
    virtual void setOperatorNumber(int a, int b) {
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult() {
        return mA * mB;
    }
public:
    int mA;
    int mB;
};

void test01() {
    AbstractCaculator* calcultor = new PlusCalcultor;
    calcultor->setOperatorNumber(10,20);
    cout<<calcultor->getResult()<<endl;

    delete calcultor;  //注意会变成一个野指针

    calcultor = new MinuteCalcultor;
    calcultor->setOperatorNumber(10, 20);
    cout << calcultor->getResult() << endl;

    delete calcultor;
    calcultor = nullptr;   //需要立刻置为NULL
}

int main() {
    test01();
    return 0;
}

二、迪米特法则

别名：最少知道原则

一个对象应当对其他对象尽可能少的了解（买房子只要知道高品质的就行了，细节我是不需要知道的），从而降低各个对象之间的耦合，提高系统的可维护性。==例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。（黑盒原理）

 

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//迪米特原则，又叫最少知道原则
//定义楼盘的抽象基类
class AbstractBuilding {
public:
    virtual void sale() = 0;
    virtual string getQuality() = 0;
};

//楼盘A
class BuildingA : public AbstractBuilding {
public:
    BuildingA() { mQuilty = "高品质"; };
    virtual void sale() {
        cout << "楼盘A" << mQuilty<<"被售卖！"<<endl;
    }
    virtual string getQuality() {
        return mQuilty;
    }
public:
    string mQuilty;
};

//楼盘B
class BuildingB :public AbstractBuilding {
public:
    BuildingB() { mQuilty = "低品质"; };
    virtual void sale() {
        cout << "楼盘B" << mQuilty << "被售卖！" << endl;
    }
    virtual string getQuality() {
        return mQuilty;
    }
public:
    string mQuilty;
};

//客户端--第一种调用方法，但是这种方法需要知道A与B自己的特点
void test01() {
    BuildingA* ba = new BuildingA;
    if (ba->mQuilty == "低品质楼盘") {
        ba->sale();
    }

    BuildingB* bb = new BuildingB;
    if (bb->mQuilty == "低品质楼盘") {
        bb->sale();
    }
}

//中介类--客户端只需要与中介打交道，不需要和楼盘本身交涉，但是需要总结类维护和管理楼盘类
class Mediator {
public:
    Mediator() {
        AbstractBuilding* building = new BuildingA;
        vBuilding.push_back(building);
        building = new BuildingB;
        vBuilding.push_back(building);
    };

    //对外提供接口
    AbstractBuilding* findMyBuilding(string quality) {
        //for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
        //	if ((*it)->getQuality() == quality){
        //		return *it;
        //	}
        //}
        for (auto it : vBuilding) {
            if ((it)->getQuality() == quality) {
                return it;
            }
        }
        return NULL;
    }

    ~Mediator() {
        for (vector<AbstractBuilding*>::iterator it = vBuilding.begin(); it != vBuilding.end(); it++) {
            if (*it != nullptr) {
                delete *it;
                *it= nullptr;
            }
        }
    }
public:
    vector<AbstractBuilding*> vBuilding;//管理已有的楼盘
};

void test02() {
    Mediator* mediator = new Mediator;

    AbstractBuilding* building = mediator->findMyBuilding("高品质");

    if (building != NULL) {
        building->sale();
    }
    else {
        cout << "没有符合您条件的楼盘！" << endl;
    }
}

int main() {
    test02();
    return 0;
}

 三、合成复用原则

使用继承会导致父类的任何变换都可能会影响到子类的行为；；；使用对象组合，就降低了这种依赖关系，对于继承和组合，优先使用组合。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//抽象车
class AbstractCar {
public:
    virtual void run() = 0;

};

//大众车
class Dazhong :public AbstractCar {
public:
    virtual void run() {
        cout << "大众车启动" << endl;
    }
};

//拖拉机
class Tuolaji :public AbstractCar {
public:
    virtual void run() {
        cout << "拖拉机启动" << endl;
    }
};

//笨方法，针对具体类 不适用继承
//#if 0
//class Person :public Tuolaji {
//public:
//	void Dongfeng() {
//		run();
//	}
//};
//class Person2 :public Dazhong {
//public:
//	void Dazhong() {
//		run();
//	}
//};
//#endif

//可以使用合成复用原则
class Person {
public:
    void setCar(AbstractCar* car) {
        this->car = car;
    }
    void Dongfeng() {
        this->car->run();
        if (this->car != NULL) {
            delete this->car;
            this->car = NULL;
        }
    }

public:
    AbstractCar* car;
};

void test02() {
    Person* p = new Person;
    p->setCar(new Dazhong);
    p->Dongfeng();

    p->setCar(new Tuolaji);
    p->Dongfeng();

    delete p;
}

//继承和组合优先使用组合
int main() {
    test02();
    return 0;
}

四、依赖倒转原则

 针对接口编程：依赖于抽象(接口)，不要依赖具体的实现(类)

4.1 传统依赖方向

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//银行工作人员
class BankWorker {
public:
    void saveService() {
        cout << "办理存款业务..." << endl;
    }
    void payService() {
        cout << "办理支付业务..." << endl;
    }
    void tranferService() {
        cout << "办理转账业务..." << endl;
    }

};

//中层模块
void doSaveBussiness(BankWorker* worker) {
    worker->saveService();
}

void doPayBussiness(BankWorker* worker) {
    worker->payService();
}

void doTranferBussiness(BankWorker* worker) {
    worker->tranferService();
}

void test01() {//缺点是一层依赖于一层
    BankWorker* worker = new BankWorker;
    doSaveBussiness(worker);  //办理存款业务
    doPayBussiness(worker); //办理支付业务
    doTranferBussiness(worker); //办理转账业务
}

int main()
{
    test01();
    return 0;
}

 4.2倒转原则

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//依赖倒转原则
//抽象层   银行工作人员
class AbstractWorkerBank {
public:
    virtual void doBussiness() = 0;
};

//只办理存款业务
class SaveBankWorker : public  AbstractWorkerBank {
public:
    virtual void doBussiness() {
        cout << "办理存款业务" << endl;
    }
};

//只办理转账业务
class TransferBankWorker : public  AbstractWorkerBank {
public:
    virtual void doBussiness() {
        cout << "办理存款业务" << endl;
    }
};

//只办理付款业务
class PayBankWorker : public  AbstractWorkerBank {
public:
    virtual void doBussiness() {
        cout << "办理存款业务" << endl;
    }
};

//高层模块，只依赖与抽象层
void DoBankBussiness(AbstractWorkerBank* worker) {
    worker->doBussiness();//父类指针指向什么就执行什么
    delete worker;
}

void test02() {
    DoBankBussiness(new SaveBankWorker); //办理存款业务
    DoBankBussiness(new TransferBankWorker); //办理转账业务
    DoBankBussiness(new PayBankWorker); //办理付款业务
}
int main()
{
    test02();
    return 0;
}