2、设计模式原则---笔记（7大原则，开闭原则，依赖倒置原则，迪米特原则）

什么是设计模式==简单到标准化
设计模式基本原则
一、开放封闭原则

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

二、单一职责

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

三、依赖倒置原则

依赖于抽象（接口），不依赖于具体的实现（类），针对接口编程

四、接口隔离原则

一个接口只提供一种功能，不是把所有的操作都封装到一个接口中去

五、里氏替换原则

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

六、优先使用组合而不是继承原则

如果是继承，父类的任何变化都会影响到子类的行为
如果使用组合就降低了这种依赖关系

七、迪米特法则

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

（1）开闭原则—-类的改动是通过代码增加进行的，不是通过修改源代码

这里写图片描述


class BankWorker
{
public:
    void save()
    {
        cout << "存款" << endl;
    }

    void moveM()
    {
        cout << "转账" << endl;
    }

    void jiaofei()
    {
        cout << "交费" << endl;
    }
protected:
private:
};


class AbBankWorker
{
public:
    virtual void dothing() = 0;
};

class  SaveBanker : public AbBankWorker
{
public:
    virtual void dothing()
    {
        cout << "存款" << endl;
    }
};


class  MoveBanker : public AbBankWorker
{
public:
    virtual void dothing()
    {
        cout << "转账" << endl;
    }
};


void test()
{
    AbBankWorker *bw  = NULL;
    bw = new MoveBanker;
    bw->dothing(); //有多态发生
    delete bw;

    bw = new SaveBanker;
    bw->dothing();
    delete bw;
}

（2）依赖倒置原则—-依赖于抽象(接口)层，不依赖于具体的实现，针对接口编程
阿斯蒂芬
这里写图片描述


class AbBankWorker
{
public:
    virtual void dothing() = 0;
};

class  SaveBanker : public AbBankWorker
{
public:
    virtual void dothing()
    {
        cout << "存款" << endl;
    }
};


class  MoveBanker : public AbBankWorker
{
public:
    virtual void dothing()
    {
        cout << "转账" << endl;
    }
};

//11:54
class  AdvMoveBanker : public MoveBanker
{
public:
    virtual void dothing()
    {
        cout << "批量 转账" << endl;
    }
};

//14:43
class  AdvAdvMoveBanker : public MoveBanker
{
public:
    virtual void dothing()
    {
        cout << " 自动化 批量 转账" << endl;
    }
};

//框架函数 
void howDo(AbBankWorker *bw)
{
    bw->dothing(); //有多态发生
}
void main02_03()
{

    AbBankWorker *bw  = NULL;
    bw = new MoveBanker;
    howDo(bw);
    delete bw;

    bw = new SaveBanker;
    howDo(bw);
    delete bw;

    bw = new AdvMoveBanker;
    howDo(bw);
    delete bw;

    bw = new AdvAdvMoveBanker;  
    howDo(bw);  //可扩展  调用后来人写的代码
    delete bw;
}

类图
这里写图片描述

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

#define MAX 100

//cpu 接口
class Cpu
{
public:
    virtual void doWork() = 0;

};


//硬盘接口
class HardDisk
{
public:
    virtual void doWork() = 0;

};
//内存接口
class Memory
{
public:
    virtual void doWork() = 0;

};

//inter cpu
class InterCpu : public Cpu
{
public:
    virtual void doWork() 
    {
        cout << "InterCpu doworking...." << endl;
    }
};


//jsd memory
class JSDmemory : public Memory
{
public:
    virtual void doWork()
    {
        cout << "JSDmemory doworking...." << endl;
    }
};

//xishu harddisk
class XSHarddisk : public HardDisk
{
public:
    virtual void doWork()
    {
        cout << "XSHarddisk doworking...." << endl;
    }
};


class Computer 
{
public:
    Computer(Cpu * cpu,Memory *memory,HardDisk * harddisk)
    {
        this->cpu = cpu;
        this->memory = memory;
        this->harddisk = harddisk;
    }

    void dowork() 
    {
        this->cpu->doWork();
        this->memory->doWork();
        this->harddisk->doWork();

    }
private:
    Cpu * cpu;
    Memory *memory;
    HardDisk * harddisk;


};



void test01()
{
    InterCpu * cpu = new InterCpu;
    JSDmemory* memory = new JSDmemory;
    XSHarddisk* harddisk = new XSHarddisk;
    Computer *computer=NULL;
    computer = new Computer(cpu,memory,harddisk);

    computer->dowork();

    cout << "------------------------------------" << endl;
}


int main()
{
    test01();



    system("pause");
    return 0;
}

（3）迪米特法则 —不要和陌生人说话
这里写图片描述

2、设计模式原则---笔记（7大原则，开闭原则，依赖倒置原则，迪米特原则）

猜你喜欢