【设计模式】设计模式概述

目录

一、学习目标

 

二、底层思维和抽象思维

三、深入理解面向对象

四、设计原则提升为设计经验

五、面向对象的实例

六、八大设计原则

七、23种设计模式的分类 

八、重构获得模式 Refactoring to patterns

---

 

一、学习目标

 

                                  1.理解松耦合设计思想

                                  2.掌握面向对象设计原则

                                  3.掌握重构技巧改善设计

                                  4.掌握GoF核心设计模式————《设计模式：可复用面向对象软件的基础》

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

软件设计的目标——复用（复用是指编译后的二进制代码的复用）

           软件设计复杂的根本原因————变化

                           解决方法：1.分解——分而治之（复用性差）

                                             2.抽象——泛化和理想化对象（复用性好）

二、底层思维和抽象思维

底层思维：向下，如何把握机器底层从微观理解对象构造。	抽象思维：向上，如何将我们周围世界抽象为程序代码。
语言构造	面向对象
编译转换	组件封装
内存模型	设计模式
运行时机制	构架模式

三、深入理解面向对象

向下：深入理解三大面向对象机制              封装，隐藏内部实现              继承，复用现有代码              多态，改写对象行为

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

面向对象的最大优势——抵御变化（通过隔离变化，保证组件各司其职）

 

四、设计原则提升为设计经验

1.设计习语（Design Idioms）

描述与特定编程语言相关的底层模式、技巧、惯用法。

2.设计模式（Design Patterns）

主要描述类与互相通信的对象之间的组织关系，包括它们的角色、职责、协作方式等。

3.构架模式（Architectural Patterns）

描述系统中与基本结构组织关系密切的高层模式，包括子系统划分、指责，以及如何组织它们之间的规则关系。

五、面向对象的实例

此部分本来是C++的伪代码，我想用Java实现，但没有完成，备注需要修改 

结构化代码

//点的实现类
class Point{
  public int x;
  public int y;

}

//线的实现类
class Line{
  public Point start;
  public Point end;
  Line(Point start, Point end){
      this.start = start;
      this.end = end;
  }
}

//方块的实现类
class Rect{
  public Point LeftUp;
  public int width;
  public int height;
  Rect(Point LeftUp, int width, int height){
      this.LeftUp = LeftUp;
      this.width = width;
      this.height = height;
  }
}

面向对象 

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(Pen.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(Pen.Red, Leftup,width,height);
        }
}

六、八大设计原则

1.依赖倒置原则（DIP）

           * 高层模块（稳定）不应该依赖于低层模块（变化），二者都应该依赖于抽象（稳定）。

           * 抽象（稳定）不应该依赖于实现细节（变化），实现细节应该依赖于抽象（稳定）。

2.开放封闭原则（OCP）

           * 对扩展开放，对更改封闭。

           * 类模块应该是可扩展的，但不可修改。

3.单一职责原则（SRP）

           * 一个类应该仅有一个引起它变化的原因。

           * 变化的方向隐含着类的责任。

4.Liskov替换原则（LSP）

           * 子类必须能够替换它们的基类（IS-A）。

           * 继承表达类型抽象。

5.接口隔离原则（ISP）

           * 不应该强迫客户程序依赖它们不用的方法。

           * 接口应该小而完备。

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

           * 类继承通常为“白箱复用”，对象组合通常为“黑盒复用”；

           * 继承在某种程度上破坏了封装性，子类父类耦合度高；

           * 而对象组合则只是被组合的对象具有良好定义的接口，耦合度低。

7.封装变化点

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

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

           * 不将变量类型声明为某个特定的具体类，而是声明为某个接口；

           * 客户程序无需获知对象的具体类型，只需知道对象的接口；

           * 减少系统中各部分的依赖关系，从而实现“高内聚，低耦合”的类型设计方案。

七、23种设计模式的分类 

1.组件协作（3）	Template Method Strategy Observer/Event
2.单一职责（2）	Decorator Bridge
3.对象创建（4）	Factory Method Abstract Factory Prototype Builder
4.对象性能（2）	Singleton Flyweight
5.接口隔离（4）	Facade Proxy Mediator Adapter
6.状态变化（2）	Memento State
7.数据结构（3）	Composite Iterator Chain of Responsibility
8.行为变化（2）	Command Visitor
9.领域问题（1）	Interpreter

 

八、重构获得模式 Refactoring to patterns

             *面向对象设计模式——应对变化，提高复用

             *现代软件设计的特征——需求的频率变化

                               设计模式要点： 寻找变化点，在变化点应用设计模式；

                                                          即什么时候，什么地点应用设计模式。

              *敏捷开发提倡 Refactoring to patterns

               重构关键技法：

                                           静态 —— 动态

                                        早绑定 —— 晚绑定

                                            继承 —— 组合

                                 编译时依赖 —— 运行时依赖

                                        紧耦合 —— 松耦合