设计模式1：设计模式简介

目标

• 理解松耦合设计思想 
• 掌握面向对象设计原则 
• 掌握重构技法改善设计 
• 掌握GOF核心设计模式

参考书籍： 《设计模式：可复用面向对象软件的基础》

一、软件设计

什么是设计模式：

“每一个描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案。这样，你就能一次又一次地使用该方案而不必做重复劳动”。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——Christopher Alexander

　　设计模式描述了软件设计过程中某一类常见问题的一般性的解决方案。

　　面向对象设计模式描述了面向对象设计过程中、特定场景下、类与相互通信的对象之间常见的组织关系。

程序开发的两种思维 

1.底层思维 

• 语言构造

• 编译转换 

• 内存模型 

• 运行时机制

2.抽象思维

 • 面向对象

 • 组件封装

• 设计模式 

• 架构模式

深入理解面向对象

• 向下：深入理解三大面向对象机制

　　　　• 封装，隐藏内部实现
　　　　• 继承，复用现有代码
　　　　• 多态，改写对象行为

• 向上：深刻把握面向对象机制所带来的抽象意义，理解如何使用这些机制来表达现实世界，掌握什么是“好的面向对象设计”

 软件设计固有的复杂性

　　建筑商从来不会去想给一栋已建好的100层高的楼房底下再新修一个小地下室——这样做花费极大而且注定要失败。然而令人惊奇的是，软件系统的用户在要求作出类似改变时却不会仔细考虑，而且他们认为这只是需要简单编程的事。
　　　　　　　　　　　　　　　　　　—Object-Oriented Analysis and Design with Applications   ：Grady Booch

软件设计复杂的根本原因

　　变化

• 客户需求的变化、 技术平台的变化、 开发团队的变化、 市场环境的变化
• ...................

如何解决复杂性？

分解
　　• 人们面对复杂性有一个常见的做法：即分而治之，将大问题分解为多个小问题，将复杂问题分解为多个简单问题。
抽象
　　• 更高层次来讲，人们处理复杂性有一个通用的技术，即抽象。由于不能掌握全部的复杂对象，我们选择忽视它的非本质细节，而去处理泛化和理想化了的对象模型。

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

　　使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

我们在解决问题的时候，常常采取两种方式，一种是分解问题，另一种是抽象。

　　对于分解来说，其实就是分而治之，把大问题不断的划分为一个又一个的小问题，通过解决分解开的每一个小问题来解决整体的大问题。也就是不断的分工，各司其职来解决问题。

　　而抽象则属于更高的层次，从我们需要解决的问题出发，在与该问题相关的一组关联对象中提取出主要的或共有的部分――说简单一点，就是用相同的行为来操作不同的对象。

先来看看第一种方式解决问题的伪代码：

class Point{
public:
    int x;
    int y;
};

class Line{
public:
    Point start;
    Point end;

    Line(const Point& start, const Point& end){
        this->start = start;
        this->end = end;
    }
};

class Rect{
public:
    Point leftUp;
    int width;
    int height;

    Rect(const Point& leftUp, int width, int height){
        this->leftUp = leftUp;
        this->width = width;
        this->height = height;
    }

};

//增加
class Circle{


};
 

class MainForm : public Form {
private:
    Point p1;
    Point p2;

    vector<Line> lineVector;
    vector<Rect> rectVector;
    //改变
    vector<Circle> circleVector;

public:
    MainForm(){
        //...
    }
protected:
    virtual void OnMouseDown(const MouseEventArgs& e);
    virtual void OnMouseUp(const MouseEventArgs& e);
    virtual void OnPaint(const PaintEventArgs& e);
};


void MainForm::OnMouseDown(const MouseEventArgs& e){
    p1.x = e.X;
    p1.y = e.Y;

    //...
    Form::OnMouseDown(e);
}

void MainForm::OnMouseUp(const MouseEventArgs& e){
    p2.x = e.X;
    p2.y = e.Y;

    if (rdoLine.Checked){
        Line line(p1, p2);
        lineVector.push_back(line);
    }
    else if (rdoRect.Checked){
        int width = abs(p2.x - p1.x);
        int height = abs(p2.y - p1.y);
        Rect rect(p1, width, height);
        rectVector.push_back(rect);
    }
    //改变
    else if (...){
        //...
        circleVector.push_back(circle);
    }

    //...
    this->Refresh();

    Form::OnMouseUp(e);
}

void MainForm::OnPaint(const PaintEventArgs& e){

    //针对直线
    for (int i = 0; i < lineVector.size(); i++){
        e.Graphics.DrawLine(Pens.Red,
            lineVector[i].start.x, 
            lineVector[i].start.y,
            lineVector[i].end.x,
            lineVector[i].end.y);
    }

    //针对矩形
    for (int i = 0; i < rectVector.size(); i++){
        e.Graphics.DrawRectangle(Pens.Red,
            rectVector[i].leftUp,
            rectVector[i].width,
            rectVector[i].height);
    }

    //改变
    //针对圆形
    for (int i = 0; i < circleVector.size(); i++){
        e.Graphics.DrawCircle(Pens.Red,
            circleVector[i]);
    }
    //...
    Form::OnPaint(e);
}

　　上面的伪代码可以用来解决点、直线和矩形的绘制，但是遇到绘制其他图形的时候就会遇到问题，必须对原伪代码进行繁琐的修改，具体修改不再进行。
如果使用另外一种方法，抽象的设计思路时，这个问题就会迎刃而解，伪代码如下：

class Shape{
public:
    virtual void Draw(const Graphics& g)=0;
    virtual ~Shape() { }
};


class Point{
public:
    int x;
    int y;
};

class Line: public Shape{
public:
    Point start;
    Point end;

    Line(const Point& start, const Point& end){
        this->start = start;
        this->end = end;
    }

    //实现自己的Draw，负责画自己
    virtual void Draw(const Graphics& g){
        g.DrawLine(Pens.Red, 
            start.x, start.y,end.x, end.y);
    }

};

class Rect: public Shape{
public:
    Point leftUp;
    int width;
    int height;

    Rect(const Point& leftUp, int width, int height){
        this->leftUp = leftUp;
        this->width = width;
        this->height = height;
    }

    //实现自己的Draw，负责画自己
    virtual void Draw(const Graphics& g){
        g.DrawRectangle(Pens.Red,
            leftUp,width,height);
    }

};


class MainForm : public Form {
private:
    Point p1;
    Point p2;

    //针对所有形状
    vector<Shape*> shapeVector;

public:
    MainForm(){
        //...
    }
protected:

    virtual void OnMouseDown(const MouseEventArgs& e);
    virtual void OnMouseUp(const MouseEventArgs& e);
    virtual void OnPaint(const PaintEventArgs& e);
};


void MainForm::OnMouseDown(const MouseEventArgs& e){
    p1.x = e.X;
    p1.y = e.Y;

    //...
    Form::OnMouseDown(e);
}

void MainForm::OnMouseUp(const MouseEventArgs& e){
    p2.x = e.X;
    p2.y = e.Y;

    if (rdoLine.Checked){
        shapeVector.push_back(new Line(p1,p2));
    }
    else if (rdoRect.Checked){
        int width = abs(p2.x - p1.x);
        int height = abs(p2.y - p1.y);
        shapeVector.push_back(new Rect(p1, width, height));
    }
    else if (...){
        //...
        shapeVector.push_back(circle);
    }

    //...
    this->Refresh();

    Form::OnMouseUp(e);
}

void MainForm::OnPaint(const PaintEventArgs& e){

    //针对所有形状
    for (int i = 0; i < shapeVector.size(); i++){

        shapeVector[i]->Draw(e.Graphics); //多态调用，各负其责
    }

    //...
    Form::OnPaint(e);
}

　　从上面的伪代码可以看出，对每个形状增加了一个共同的父类Shape，同时在父类中定义了纯虚函数Draw，使得在多态调用的时候每个子类可以按照自己的方式来实现Draw函数。而界面类MainForm变成只需管理Shape的指针，不再是某个具体的对象，实现了向上抽象的管理。

如果这时候我们增加一个圆形的画法，那么我们只需在class Rect后面增加以下代码：

class Circle : public Shape{
public:
    //实现自己的Draw，负责画自己
    virtual void Draw(const Graphics& g){
        g.DrawCircle(Pens.Red,
            ...);
    }
};

　　第一种方法是采用面向对象语言的结构化编程方法：当有新的类型增加时，几乎所有设计到类型的地方（包括MainForm::OnPaint 方法）都要做改变...这些代码都需要重新编译，重新部署...

　　第二种是面向对象做法：只需要在新的文件里添加新的图形类，让其继承自Shape抽象类，并重写Draw()方法，产生新的类型就可以了。其他地方则不需要任何改变。

　　通过以上的代码可以看出，当我们使用抽象思维对代码进行设计的时候，使得代码的变更更加容易，代码的复用性得到了提升，它是通过面向对象中的继承和多态性来实现。

　　作为一名程序员或者说是未来的程序员，抽象思维非常重要，甚至在某种程度上比底层思维更加重要，它在C++程序设计中主要包括以下几个部分：面向对象，组件封装，设计模式，架构模式。

软件设计的目标

　　什么是好的软件设计？软件设计的金科玉律：
　　　　　　　　　　　　　　复用！

二、面向对象设计 

面向对象设计，为什么？

变化是复用的天敌！
面向对象设计最大的优势在于：

抵御变化！
抵御变化！

 　　软件设计复杂的根本原因是因为它会遇到各种各样的变化：客户需求变化，技术平台变化，开发团队变化，市场环境变化等等。

　　抽象思维的最大特点是复用性，也就可以抵御这些变化。在1中我们谈到面向对象是抽象思维实现的基础，先让我们重新认识面向对象：

重新认识面向对象

• 理解隔离变化

• 从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响减为最小

• 各司其职

• 从微观层面来看，面向对象的方式更强调各个类的“责任”
• 由于需求变化导致的新增类型不应该影响原来类型的实现——是所谓各负其责

• 对象是什么？

• 从语言实现层面来看，对象封装了代码和数据。
• 从规格层面讲，对象是一系列可被使用的公共接口。
• 从概念层面讲，对象是某种拥有责任的抽象。

---

怎样才能设计“好的面向对象”？

　遵循一定的面向对象设计原则

　熟悉一些典型的面向对象设计模式

　　为了确保设计出来地系统具有抽象思维的特性，面向对象设计中提出了一系列的基本原则作为设计的思想。

面向对象设计原则

（1）依赖倒置原则（DIP） 

• 高层模块(稳定)不应该依赖于低层模块(变化)，二者都应该依赖于抽象(稳定)。
• 抽象(稳定)不应该依赖于实现细节(变化)，实现细节应该依赖于抽象(稳定)。 

（2）开放封闭原则（OCP） 

• 对扩展开放，对更改封闭
• 模块应该是可扩展的，但是不可修改 

（3）单一指责原则（SRP）

• 一个类应该仅有一个引起它变化的原因
• 变化的方向隐含着类的责任

（4）Liskov替换原则（LSP）

• 子类必须能够替换他们的基类（is-a）
• 集成表达抽血类型

（5）接口隔离原则（ISP）

• 不应该强迫客户程序依赖他们不用的方法
• 接口应该小而完备

（6）优先使用对象组合，而不是类继承

• 类继承通常为“白盒复用”，对象组合通常为“黑箱复用”
• 继承在某种程度上破坏了封装性，子类父类耦合度高
• 而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低

（7）封装变化点

• 使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧进行修改，而不会对另一侧产生不良的影响，从而实现层次间的松耦合

（8）针对接口编程，而不是针对实现编程

• 不将变量类型声明为某个特定的具体类，而是声明为某个接口
• 客户程序无需获知对象的具体类型，只需要知道对象所具有的接口
• 减少系统中个部分的依赖关系，从而实现“高内聚、松耦合”的类型设计方案

面向接口设计

　　产业强盛的标志-——接口的标准化

将设计原则提升为设计经验

 1. 设计习语 Design Idioms
　　• Design Idioms 描述与特定编程语言相关的低层模式，技巧，惯用法。
 2. 设计模式 Design Patterns
　　• Design Patterns主要描述的是“类与相互通信的对象之间的组织关系，包括它们的角色、职责、协作方式等方面。
 3. 架构模式 Architectural Patterns
　　• Architectural Patterns描述系统中与基本结构组织关系密切的高层模式，包括子系统划分，职责，以及如何组织它们之间关系的规则。

设计模式与面向对象 

　　面向对象设计模式解决的是“类与相互通信的对象之间的组织关系”，包括它们的角色、职责、协作方式几个方面。

　　面向对象设计模式是“好的面向对象设计”，所谓“好的面向对象设计”是那些可以满足“应对变化，提高服用”的设计。

　　面向对象设计模式描述的是软件设计，因此它是独立于编程语言的，但是面向对象设计模式的最终实现仍然要使用面向对象编程语言来表达。

　　面向对象设计模式不像算法技巧，可以照搬照用，它是建立在对“面向对象”纯熟、深入的理解的基础上的经验性知识。掌握面向对象设计模式的前提是首先掌握“面向对象”！

三、GoF 23种设计模式

　　历史性著作《设计模式：可复用面向对象软件的基础》一书中描述了23种经典面向对象设计模式，创立了模式在软件设计中的地位。该书四位作者被人们并成为Gang of Four（GoF），“四人组”，该书描述的23种经典设计模式又被人们称为GoF23种设计模式。

　　由于《设计模式：可复用面向对象软件的基础》一书确定了设计模式的地位，人们通常所说的设计模式隐含地表示“面向对象设计模式”。但这并不意味“设计模式”就等于“面向对象设计模式”。除了“面向对象设计模式”外，还有其他设计模式。除了GoF23中设计模式外，还有更多的面向对象设计模式。GoF23种设计模式是学习面向对象设计模式的起点，而非终点。

 GOF-23模式分类

（1）从目的来看

• 创建型（Creational）模式：将对象的部分创建工作延迟到子类或者其他对象，从而应对需求变化为对象创建时具体类型实现引来的冲击。
• 结构型（Structural）模式：通过类继承或者对象组合的方式来获得更灵活的结构，从而应对需求变化为对象的结构带来的冲击。
• 行为型（Behavioral）模式：通过类继承或者对象组合的方式，来划分类与对象的指责，从而应对需求变化为多个交互的对象带来的冲击。

（2）从范围来看

• 类模式处理类与子类的静态关系
• 对象模式处理对象间的动态关系 

		目的
		创建型	结构型	行为型
范围	对象	Factory Method	Adapter_Class	Interpreter Template Method
	类	Abstract Factory Builder Prototype Singleton	Adapter_Object Bridge Composite Decorator Facade Flyweight Proxy	Chain of Responsibility Command Iterator Mediator Memento Observer State Strategy Visitor

 

（3）从封装变化角度对模式分类

设计模式之间的关系

 

重构获得模式 Refactoring to Patterns

　　通过重构获得模式，我们来正确使用对应的设计模式。

• 面向对象设计模式是“好的面向对象设计”，所谓“好的面向对象设计”指是那些可以满足 “应对变化，提高复用”的设计 。
• 现代软件设计的特征是“需求的频繁变化”。设计模式的要点是“寻找变化点，然后在变化点处应用设计模式，从而来更好地应对需求的变化”; “什么时候、什么地点应用设计模式”比“理解设计模式结构本身”更为重要。
• 设计模式的应用不宜先入为主，一上来就使用设计模式是对设计模式的最大误用。没有一步到位的设计模式。敏捷软件开发实践提倡的“Refactoring to Patterns”是目前普遍公认的最好的使用设计模式的方法。
  

---

重构关键技法

• 静态⇰动态
• 早绑定 ⇰ 晚绑定
• 继承 ⇰ 组合
• 编译时依赖 ⇰ 运行时依赖
• 紧耦合 ⇰ 松耦合

---

 四、总结

　　设计模式描述了软件设计过程中某一类常见问题的一般性的解决方案。面向对象设计模式描述了面向对象设计过程中、特定场景下、类与相互通信的对象之间常见的组织关系。

　　深刻理解面向对象是学好设计模式的基础，掌握一定的面向对象设计原则才能把握面向对象设计模式的精髓，从而实现灵活运用设计模式。

　　三大基本面向对象设计原则

　　　　-针对接口编程，而不是针对实现编程

　　　　-优先使用对象组合，而不是类继承

　　　　-封装变化点

　　使用重构得到模式。敏捷软件开发实践提倡的“Refactoring to Patterns”是目前普遍公认的最好的使用设计模式的方法。

 

本文内容源自 ：C++设计模式 Design Patterns 李建忠  课程
博客: http://blog.csdn.net/Sylar2016/article/details/73927784

一些其他文章：

20年前GoF提出的设计模式，对这个时代是否还有指导意义？
http://www.infoq.com/cn/articles/design-patterns-proposed-by-gof-20-years-ago

GoF设计模式三作者15年后再谈模式
http://www.jdon.com/37356

23种设计模式全解析 - 博客园 https://www.cnblogs.com/geek6/p/3951677.html  (java)