设计模式基本原则

设计模式

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

设计模式基本原则

最终目的：高内聚、低耦合。
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. 通过抽象的陌生人和陌生人讲话