设计模式基本原则

设计模式

   设计模式就是 把简单的问题复杂化标准化，把环境中的各个部分进行抽象、归纳、解耦合。

设计模式基本原则

最终目的：高内聚、低耦合。
1. 开放封闭原则（OCP，Open Closed Principle）

类的改动是通过增加代码进行的，而不是修改源代码。

# include <iostream>using namespace std;class BankWorker{public:    void  Save()    {        cout << "存款" << endl;    }    void MoveMoney()    {        cout << "转账" << endl;    }    void JiaoFei()    {        cout << "缴费" << endl;    }};class AbBankWorker{public:    virtual void  dothing() = 0;};class SaveBanker :public AbBankWorker{    virtual void dothing()    {        cout << "存款" << endl;    }};class MoveBanker :public AbBankWorker{    virtual void dothing()    {        cout << "转账" << endl;    }};class AdvMoveBanker :public MoveBanker{    virtual void dothing()    {        cout << "批量转账" << endl;    }};class JiaoBanker :public AbBankWorker{    virtual void dothing()    {        cout << "缴费" << endl;    }};void main02_01(){    BankWorker *bw = new BankWorker;    bw->JiaoFei();    bw->MoveMoney();    bw->Save();    return;}//框架函数void howDo(AbBankWorker *bw){    bw->dothing();//有多态发生}void main02_02(){    AbBankWorker *bw=NULL;    bw = new SaveBanker;    bw->dothing();    delete bw;    bw = new MoveBanker;    bw->dothing();    delete bw;    bw = new JiaoBanker;    bw->dothing();    delete bw;    return;}void main02_03(){    AbBankWorker *bw = NULL;    bw = new MoveBanker;    howDo(bw);    delete bw;    bw = new JiaoBanker;    howDo(bw);    delete bw;    bw = new SaveBanker;    howDo(bw);    delete bw;    bw = new AdvMoveBanker;    howDo(bw);    delete bw;    return;}void main(){    main02_01();    main02_02();    main02_03();    system("pause");}

2.单一职责原则(SRP,Single responsibility principle)

    类的职责要单一。对外只提供一种功能，而引起类变化的原因都应只有一个。

3.依赖倒置原则(DIP,Dependence Inversion Principle )

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

• 传统的设计模式
  
• 非传统的设计模式
  

一个集成框架集成多个产品模型图

# include <iostream>using namespace std;//让 Computer 框架 和具体的厂商 进行解耦合class HardDisk{public:     virtual void work() = 0;};class Memory{public:    virtual void work() = 0;};class Cpu{public:    virtual void work() = 0;};class Computer{public:    Computer(HardDisk *handdisk, Memory *memory, Cpu *cpu)    {        m_handdisk = handdisk;        m_memory = memory;        m_cpu = cpu;    }    void work()    {        m_handdisk->work();        m_memory->work();        m_cpu->work();    }    /*HardDisk    Memory     Cpu */private:    HardDisk *m_handdisk;    Memory *m_memory;    Cpu *m_cpu;};class InterCpu:public Cpu{public:    virtual void work()    {        cout << "我是inter cpu 我工作良好" << endl;    }};class XSHardDisk :public HardDisk{public:    virtual void work()    {        cout << "我是西数硬盘  我工作良好" << endl;    }};class JSDMemory :public Memory{public:    virtual void work()    {        cout << "我是金士顿内存  我工作良好" << endl;    }};void main(){    Memory *mem = NULL;    HardDisk *disk = NULL;    Cpu *cpu = NULL;    mem = new JSDMemory;    disk = new XSHardDisk;    cpu = new InterCpu;    Computer *mycomputer= new Computer(disk, mem, cpu);    mycomputer->work();    delete mycomputer;    delete cpu;    delete disk;    delete mem;    system("pause");    return;}

4.接口隔离原则(ISP,Interface Segregation Principle)

 不应该强迫客户的程序依赖他们不需要的接口方法。一个接口应该只提供一种对外功能，不应该把所有操作都装到一个接口中去。

5.里氏替换原则(LSP，Liskov Substitution Principle)

 任何抽象类出现的地方都可以用他的实现类进行替换，时间就是多态机制，语言级别实现面向对象功能。

6.合成/聚合复用原则(CARP，Composite/Aggregate Reuse Principle )

优先考虑使用组合而不是考虑继承。如果使用继承，会导致父类的任何变换都有可能影响到子类的行为，而使用组合不会影响到他模块的使用。

7.迪米特法则(LOD,Law of Demeter)

一个对象应对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如，在一个程序中个，各个模块之间相互调用时，通常会提供一个系统过的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节。这样当一个模块内部的实现发生改变时，不会影响其他模块的使用(黑盒测试)。

举例

1. 直接和陌生人讲话(有一定的危险性)

   

2. 通过朋友和陌生人讲话(对朋友的依赖性太大)

   

3. 通过抽象的陌生人和陌生人讲话