设计模式简单地说是“代码的模板”，它定义了某种对象或类如何创建、使用、销毁。

在现代高级语言中（Kotlin、swift等），已经将设计模式潜移默化地融入了语法中。（个人理解）

函数式编程也许可以很方便地实现设计模式所要实现的功能。（个人理解）

参考文档

总览

设计模式共分类三类：

  • 创建型：提供创建对象的机制， 能够提升已有代码的灵活性和可复用性。
    单例、工厂、抽象工厂、原型、建造者
  • 结构型：将对象和类组装成较大的结构， 并同时保持结构的灵活和高效。
    适配器、桥接、装饰者、组合、外观、享元、代理
  • 行为型：主要用于处理对象之间的交互和职责分配。
    观察者、策略、模板方法、命令、责任链、状态、迭代器、访问者、中介者、备忘录、解释器

创建型

创建型模式常用与创建对象。

单例模式 Singleton

单例模式是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。

  • 保证一个类只有一个实例。
    如数据库、文件，或较重的Context等。
  • 为该实例提供一个全局访问节点。
    全局变量相对来说不安全，因为任何代码都可以覆盖它。单例可以保护实例不被覆盖。同时相对全局变量，变量放在类中更好组织代码。
1
2
3
4
5
6
7
8
9
10
class 单例类 {
    静态变量 shared = new 单例类();
    变量1 = 1;
    私有 方法(){ }
    方法1(){ }
}

// 调用
单例类.shared.方法1();
变量 = 单例类.shared.变量1;

使用枚举类型实现单例更优雅、安全。

1
2
3
enum 单例类 {
    静态变量 shared = new 单例类();
}

工厂模式 Factory Method

工厂方法模式是一种创建型设计模式， 其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。

1
2
3
4
5
6
7
8
9
10
11
public class 工厂 {
    变量 = 1;
    获取对象A(){
        return 对象A;
    }
    获取对象B(){
        return 对象B;
    }
}
// 调用
变量 = 工厂.获取对象A();

抽象工厂模式 Abstract Factory

简单而言，将多个工厂封装到一个抽象工厂中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
abstract class 抽象工厂 {
    成员变量 = 1;
    抽象方法A();
    抽象方法B();
}
public class 工厂A 继承 抽象工厂 {
    override 方法A(){ }
}
public class 工厂B 继承 抽象工厂 {
    override 方法A(){ }
}
// 调用
变量a = 工厂A.方法A();
变量b = 工厂B.成员变量;

原型模式 Prototype

使你能够复制已有对象， 而又无需使代码依赖它们所属的类。（一些对象拥有私有属性，这些对象本身外部不可见）
原型模式将克隆过程委派给被克隆的实际对象。
克隆包含循环引用的复杂对象可能会非常麻烦。

1
2
3
4
5
6
7
8
9
10
11
public class 原型类 {
    私有成员 = 1;
    私有 方法(){ }
    copy() {    
        原型变量 = new 原型类();
        原型变量.私有成员 = this.私有成员;
        return 原型变量;
    }
// 调用
 原型类实例 = new 原型类();
变量 = 原型类实例.copy();

建造者模式 Builder

使你能够分步骤创建复杂对象。 该模式允许你使用相同的创建代码生成不同类型和形式的对象。
对象的创建过程复杂时：当创建一个复杂对象需要多个步骤，并且这些步骤的顺序很重要时，可以使用生成器模式。
根据不同的条件创建不同类型的对象：可以通过不同的具体生成器来创建不同类型的产品。
创建对象的算法较为复杂时：将复杂的算法封装在生成器中，使得客户代码更加简洁。
将创建过程、组装过程拆分开来。即由生成器定义产品、定义组装过程，由指挥者执行生成器的组装过程。

  • 产品（Product）：最终要生成的复杂对象。
  • 抽象生成器（Builder）：定义了创建产品各个部分的抽象方法。
  • 具体生成器（Concrete Builder）：实现抽象生成器的方法，负责具体产品的构建。
  • 指挥者、主管（Director）：负责使用生成器对象来构建产品，它隔离了客户与产品的具体构建过程。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class 产品 {
    private 成员1;
    set成员1(int 成员1) {
        this.成员1 = 成员1;
    }
}
abstract class 产品Builder {
    产品 产品;
    方法1();
}
public class 具体生成器 extends 产品Builder {
    override 方法1(){}
}
public class 指挥者 {
    指挥(产品Builder builder) {
        builder.方法1();
    }
}
// 调用
指挥者 = new 指挥者();
具体生成器 = new 具体生成器();
指挥者.指挥(具体生成器); // 构建产品

结构型

结构型模式介绍如何将对象和类组装成较大的结构， 并同时保持结构的灵活和高效。

适配器模式 Adapter

它能使接口不兼容的对象能够相互合作。

桥接模式 Bridge

可将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构，从而能在开发时分别使用。

组合模式 Composite

你可以使用它将对象组合成树状结构，并且能像使用独立对象一样使用它们。

装饰模式 Decorator

允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。

外观模式 Facade

能为程序库、框架或其他复杂类提供一个简单的接口。

享元模式 Flyweight

摒弃了在每个对象中保存所有数据的方式，通过共享多个对象所共有的相同状态，让你能在有限的内存容量中载入更多对象。

代理模式 Proxy

让你能够提供对象的替代品或其占位符。 代理控制着对于原对象的访问， 并允许在将请求提交给对象前后进行一些处理。

行为型

行为模式负责对象间的高效沟通和职责委派。

责任链模式 Chain of Responsibility

允许你将请求沿着处理者链进行发送。 收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。

命令模式 Command

允许你将请求沿着处理者链进行发送。 收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。

迭代器模式 Iterator

让你能在不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素。

中介者模式 Mediator

能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作。

备忘录模式 Memento

能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作。

观察者模式 Observer

允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象。

状态模式 State

让你能在一个对象的内部状态变化时改变其行为， 使其看上去就像改变了自身所属的类一样。

策略模式 Strategy

它能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。

模板方法模式 Template Method

它能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。

访问者模式 Visitor

它能让你定义一系列算法， 并将每种算法分别放入独立的类中， 以使算法的对象能够相互替换。