1.设计模式概述

如果把修习软件开发当作武功修炼的话，那么可以分为内功和外功

image.png

招式：
Java，C#,C++等编程语言
Eclipse，Android Studio, XCode等开发工具
Struts Hibernate,JBPM等框架技术
内功：数据结构，算法，设计模式，重构，软件工程。

每一位软件开发人员也都希望成为一名兼具淋漓招式和深厚内功的“上
乘”软件工程师，而对设计模式的学习与领悟将会让你“内功”大增，再结合
你日益纯熟的“招式”，你的软件开发“功力”一定会达到一个新的境界。

招式可以很快学会，但是内功修炼需要很长等时间

设计模式有何而来？

模式之父：Christopher Alexander（克里斯托弗.亚历山大）———哈佛大学建筑学
博士、美国加州大学伯克利分校建筑学教授、加州大学伯克利分校环境结构研
究所所长、美国艺术和科学院院士。

“每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题
的解决方案的核心，通过这种方式，我们可以无数次地重用那些已有的成功的
解决方案，无须再重复相同的工作。”
——《建筑的永恒之道》by Christopher Alexander

软件设计模式又从何而来?

四人组（Gang of Four）简称GoF

image.png

GoF将模式的概念引入软件工程领域，这标志着软件模式的诞生。软件
模式(Software Patterns)是将模式的一般概念应用于软件开发领域，即软件开
发的总体指导思路或参照样板。软件模式并非仅限于设计模式，还包括架构模
式、分析模式和过程模式等，实际上，在软件开发生命周期的每一个阶段都存
在着一些被认同的模式。
软件模式与具体的应用领域无关，也就是说无论你从事的是移动应用开
发、桌面应用开发、Web应用开发还是嵌入式软件的开发，都可以使用软件模
式。无论你是使用Java、C#、Objective-C、VB.net、Smalltalk等纯面向对象
编程语言，还是使用C++、PHP、Delphi、JavaScript等可支持面向对象编程
的语言，你都需要了解软件设计模式！

“软件设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过
分类编目的、代码设计经验的总结，使用设计模式是为了可重用代码、让代码
更容易被他人理解并且保证代码可靠性。”

设计模式用来干什么？

在一定的环境下，用固定的套路解决问题

设计模式种类

• 创建型(Creational)模式： 如何创建对象；
• 结构型(Structural )模式： 如何实现类或对象的组合；
• 行为型(Behavioral)模式： 类或对象怎样交互以及怎样分配职责。

设计模式总览

image.png

设计模式原则

原则的目的：高内聚，低耦合

image.png

列举案例

1.开闭原则

image.png

#include <iostream>
#include    <iostream>
using namespace std;
/*
如果想要再添加新功能，需要再次添加新的成员函数
这样的话，会使类越来越臃肿。
    */
class   BankWorker  {
public:
    void    save()  {

    cout    <<  "存款"    <<  endl;
    }
void    transfer()  {
        cout    <<  "转账"    <<  endl;
    }
void    pay()   {
        cout    <<  "交费"    <<  endl;

    }
};
//修改后新增业务只需要继承抽象类
class   AbBankWorker    {
public:
/*  纯虚函数 ⽤来抽象 银⾏业务员的业务  */
    virtual void    doBusiness()    =   0;
};

class   saveBankWorker  :   public  AbBankWorker    {
public:
    virtual void    doBusiness()    {
        cout    <<  "存款"    <<  endl;
    }
};
class   transBankWorker :   public  AbBankWorker    {
public:
    virtual void    doBusiness()    {
        cout    <<  "转账"    <<  endl;
    }
};
class   payBankWorker   :   public  AbBankWorker    {
    virtual void    doBusiness()    {
        cout    <<  "付款"    <<  endl;
    }
};
int main() {
    //如果需要挂失，改密码等又需要去修改这个类
    BankWorker bankWorker;
    bankWorker.pay();
    bankWorker.transfer();
    bankWorker.save();

    AbBankWorker *abBankWorker;
    abBankWorker=new saveBankWorker();
    abBankWorker->doBusiness();
    abBankWorker=new transBankWorker();
    abBankWorker->doBusiness();
    abBankWorker=new payBankWorker();
    abBankWorker->doBusiness();
    
    return 0;
}

这样，如果我们给银行业务员添加业务，那么无需修改原来的类中代码，
而是通过拓展添加类的方式来搞定，实际上是利用了多态的特性，这样就符合
了开闭原则。

依赖倒置原则

image.png

传统的过程设计倾向于使用高层次的模块依赖低层次的模块，抽象层依赖于具体的层次。

image.png

传统的设计模式通常是自顶向下逐级依赖，这样，底层模块，中间层模
块和高层模块的耦合度极高，若任意修改其中的一个，很容易导致全面积的修
改，非常麻烦，那么依赖倒转原则利用多态的先天特性，对中间抽象层进行依
赖，这样，底层和高层之间进行了解耦合。

/*
抽象层,    中间层
    */
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(Cpu *cpu, Memory *mem, HardDisk *hard) {
        this->cpu = cpu;
        this->memory = mem;
        this->harddisk = hard;
    }

//⾼层的业务逻辑,并不关⼼是哪个⼚商的，只是对抽象层的每个硬件的业务。
    void work() {
        cpu->work();
        memory->work();
        harddisk->work();
    }

private:
    HardDisk *harddisk = NULL;
    Memory *memory = NULL;
    Cpu *cpu = NULL;
};
//实现层， 只需要依赖中间抽象层，实现抽象层中的⽅法
class   XiJieHardDisk:public HardDisk   {
public:
    virtual void work() {
        cout    <<  "希捷硬盘⼯作中……" <<  endl;
    }
};
class   IntelCpu:public Cpu {
public  :
    virtual void work() {
        cout    <<  "intel  CPU ⼯作中……"  <<  endl;
    }
};
class   JSDMemory   :public Memory  {
public:
    virtual void    work()  {
        cout    <<  "⾦斯顿内存⼯作中……"    <<  endl;
    }
};
int main() {
    XiJieHardDisk *xiJieHardDisk=new XiJieHardDisk();
    IntelCpu *intelCpu=new IntelCpu();
    JSDMemory *jsdMemory=new JSDMemory();
    Computer computer(intelCpu,jsdMemory,xiJieHardDisk);
    computer.work();
    return 0;
}

合成复用模式

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;
class Cat
{
public:
    void sleep() {
        cout << " 小猫睡觉了" << endl;
    }
};

//向给猫添加一个功能， 创建一个新的猫 既能够睡觉，又能吃东西
//通过继承的方式完成
class AdvCat :public Cat{
public:
    void eatAndSleep() {
        cout << "吃东西" << endl;
        sleep();
    }
};


//使用组合的方式来添加小猫的吃东西方法
//使用组合的方式，降低了AdvCat2 和Cat的耦合度， 跟Cat的父类没有任何关系，
//只跟Cat的sleep方法有关系
class AdvCat2
{
public:
    AdvCat2(Cat *cat)
    {
        this->cat = cat;
    }

    void eatAndSleep() {
        cout << "吃东西" << endl;
        cat->sleep();
    }
private:
    Cat *cat;
};


int main(void)
{
    Cat c;
    c.sleep();

    AdvCat ac;
    ac.eatAndSleep();

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

    AdvCat2 ac2(&c);
    ac2.eatAndSleep();
    
    return 0;
}

总结：
以上是设计模式的描述，下面会有三篇文章来详细说明列举
创造型模式，结构型模式，行为型模式