设计模式入门：从建筑图纸到代码世界

第1章：设计模式入门：从建筑图纸到代码世界

当你走进一座宏伟的建筑，比如北京的国家体育场（鸟巢）或上海的金茂大厦，你是否曾想过，这些令人惊叹的建筑是如何从设计师脑海中的构想变成矗立在现实中的实物的？答案就是——图纸。在建筑师开始动工之前，他们会绘制详细的设计图纸，标注每一个尺寸、每一种材料、每一道工序。这些图纸不是凭空想象的，而是建筑师们在数百年的实践中总结出来的、被反复验证过的智慧结晶。

当你组装一件从宜家买回来的家具时，包装盒里总会有一份说明书。这份说明书会告诉你第1步做什么、第2步做什么，每一步都有清晰的图示和编号。你不需要知道为什么要这样做，只需要按照说明书的指引一步步操作，就能顺利完成组装。这份说明书，就是一种“模式”——一种经过验证的、可以反复使用的解决方案。

当你按照食谱烹饪一道菜时，食谱会告诉你需要准备哪些食材、每种食材用多少量、加热到多少度、炒多长时间。这些信息都是前人无数次尝试后总结出来的最优方案，你照着做，就能做出美味的菜肴，而不必自己去摸索每一个细节。

这些例子都在告诉我们一个重要的事实：模式（Pattern）是人类解决重复性问题的智慧结晶。它们不是某个人凭空发明的，而是在实践中被反复验证、被广泛认可的最佳实践。一旦某种方法被证明是有效的，人们就会把它总结成模式，让后来的人能够站在前人的肩膀上，不必从零开始。

从物理世界到代码世界

软件开发，本质上也是一种“建造”活动。建筑师用砖瓦和钢筋水泥构建建筑物，程序员用代码构建软件系统。两者的目标是一致的——建造出功能正确、性能优良、易于维护的作品。

然而，软件开发和建筑有一个重要的区别：建筑物一旦建成，除非推倒重建，否则很难进行大幅度的修改。但软件系统恰恰相反，它需要不断适应变化。用户需求在变、业务环境在变、技术条件在变，一个优秀的软件必须能够灵活地应对这些变化，而不至于每次变化都导致一场“灾难”。

这就引出了软件开发中的一个核心挑战：如何编写可维护、可扩展、可复用的代码？

试想一下，如果让你编写一个简单的小游戏，比如经典的俄罗斯方块，你会怎么做？也许你会这样想：这有什么难的，不就是几个方块在屏幕上落下来嘛。于是你撸起袖子开始写代码，用最直接的方式实现——所有逻辑写在一个大函数里，变量命名随意，关键代码不加注释。

一个月后，游戏完成了，确实能玩。但这时你想给游戏添加一个新功能，比如计分系统。你打开代码，发现一个月前写的代码已经像一团乱麻，连自己都快看不懂了。你花了三天时间，终于把计分功能加上去，结果发现原来的消行功能出现了奇怪的bug。

这就是软件工程中著名的“软件危机”的表现之一。1968年，北约组织的计算机科学家们在西德召开了一次历史性的会议，正式提出了“软件危机”这一概念。他们认识到，随着软件系统变得越来越复杂，传统的“手工作坊”式的开发方式已经无法满足需求。软件项目经常延期、超预算、质量低劣，许多项目甚至以失败告终。

如何解决软件危机？计算机科学家们经过数十年的探索，逐渐形成了一套系统化的方法论，其中最重要的成果之一就是面向对象程序设计（Object-Oriented Programming, OOP）。面向对象的思想让我们能够用更接近人类思维方式的方式来组织代码，把现实世界中的事物抽象成“对象”，每个对象都有自己的数据和行为。

但是，面向对象只是提供了一种编程范式，它并没有告诉我们具体应该怎么组织类、怎么设计类之间的关系。就像面向对象告诉我们可以用砖块建造房子，但并没有告诉我们砖块应该怎么排列、门窗应该怎么设置。

正是在这样的背景下，设计模式（Design Patterns）应运而生。

GoF与《设计模式》的诞生

1994年，四位著名的计算机科学家埃里克·伽玛（Erich Gamma）、理查德·赫尔姆（Richard Helm）、拉尔夫·约翰逊（Ralph Johnson）和约翰·威利斯迪斯（John Vlissides）合著了一本划时代的著作——《设计模式：可复用面向对象软件的基础》（Design Patterns: Elements of Reusable Object-Oriented Software）。由于这四位作者都是男性，他们被称为“四人组”（Gang of Four），在软件工程领域，这个称呼几乎无人不知、无人不晓，通常简称为GoF。

这本书之所以具有里程碑意义，是因为它第一次系统化地总结和分类了面向对象软件设计中的最佳实践。GoF分析了大量的优秀面向对象软件，发现许多设计问题在不同的系统和场景中反复出现，而经验丰富的设计师们解决这些问题的方式竟然惊人地相似。于是，他们把这些相似的问题和解决方案抽取出来，形成了23种经典的设计模式。

这23种模式并不是凭空发明的，而是从实践中提炼出来的。GoF查阅了数百篇学术论文、数十个成功的软件系统，甚至借鉴了建筑学大师克里斯托弗·亚历山大（Christopher Alexander）提出的建筑模式理论。亚历山大在建筑学领域提出了“模式语言”的概念，认为优秀的建筑是由一系列相互关联的模式组成的。GoF深受这一理念的启发，将类似的思路引入到软件设计中。

《设计模式》一书出版后，迅速成为软件工程领域的经典之作。它不仅提供了一套实用的设计工具，更重要的是，它建立了一种共同的交流语言。当软件设计师们说“这个模块应该用观察者模式”时，同行们立刻就能明白他想表达什么意思，而不必长篇大论地解释具体实现细节。

三类设计模式：创建、结构与行为

GoF将23种设计模式分为三大类，这种分类方式帮助我们理解每种模式的核心职责和应用场景。

创建型模式（Creational Patterns）关注的是对象的创建机制。在面向对象编程中，对象的创建看似简单，但其中蕴含着许多设计考量。比如，如果你需要在不同的情况下创建不同类型的对象，或者你需要控制对象的创建数量，或者你需要避免对象创建过程中的耦合关系，这时创建型模式就能派上用场。本书将在第4章详细介绍工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式这五种创建型模式。

结构型模式（Structural Patterns）关注的是如何组合类和对象以形成更大的结构。现实世界中的事物往往是由多个部分组成的，软件系统也不例外。结构型模式教会我们如何将不同的类或对象组装成一个协调工作的整体，同时保持结构的灵活性和可扩展性。第5章将详细介绍适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。

行为型模式（Behavioral Patterns）关注的是对象之间的通信和职责分配。一个复杂的系统不仅需要正确的结构，还需要合理的协作方式。行为型模式定义了对象之间如何交互、如何分担责任，以及如何让算法的责任得到明确划分。第6章将详细介绍职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。

理解这三大类模式的区别，对于后续的学习至关重要。你可以把它们想象成建筑中的不同工种：创建型模式负责“生产”建筑材料，结构型模式负责“组装”建筑框架，行为型模式负责“协调”建筑内部的各种系统。

虚拟游戏世界：贯穿全书的综合案例

理论的学习总是枯燥的，最好的方式是将理论与实践结合起来。为了让读者能够更直观地理解每种设计模式的实际应用，本书将贯穿一个综合案例——虚拟游戏世界（Virtual Game World）。

想象你正在开发一个游戏引擎，这个引擎需要支持创建各种游戏角色（如战士、法师、弓箭手），处理角色之间的战斗和交互，管理游戏场景和地图，提供存档和读档功能，支持多人在线对战，等等。这是一个相当复杂的系统，如果用传统的方式编写，代码很快就会变得混乱不堪。

但如果你运用设计模式的思维来设计这个系统，你会发现代码会变得清晰、有序、易于扩展。每当你需要添加新功能时，你只需要添加新的类，而不必修改已有的代码。这就是设计模式带给我们的巨大价值。

本书将在每一章的讲解中，结合虚拟游戏世界的具体场景来说明各种设计模式的应用。我们会从最简单的功能开始，逐步构建一个完整的游戏系统。在这个过程中，你不仅会学到设计模式的知识，还会学到如何用面向对象的思维来分析和解决实际问题。

下面，让我们先通过一个简单的例子来预览一下设计模式在游戏世界中的应用。假设我们要设计一个游戏角色的属性系统，不同的角色类型（战士、法师等）有不同的发展路线，玩家可以通过升级来提升角色的属性。

如果不用设计模式，你可能会这样写：

```python

不推荐的做法：使用大量条件判断

class Character: def __init__(self, character_type): self.character_type = character_type self.health = 100 self.attack = 10 self.defense = 5

def level_up(self): if self.character_type == "warrior": self.health += 20 self.attack += 8 self.defense += 5 elif self.character_type == "mage": self.health += 10 self.attack += 12 self.defense += 2 elif self.character_type == "archer": self.health += 15 self.attack += 10 self.defense += 3

如果以后要添加新的角色类型，就不得不修改这个方法

```

这种写法的问题很明显：每次添加新的角色类型，都需要修改`level_up`方法，而且随着角色类型增多，代码会越来越难以维护。

如果使用设计模式，我们可以这样重构：

```python

策略模式示例：不同的升级策略

from abc import ABC, abstractmethod

class LevelUpStrategy(ABC): """升级策略抽象类""" @abstractmethod def apply(self, character): pass

class WarriorLevelUp(LevelUpStrategy): def apply(self, character): character.health += 20 character.attack += 8 character.defense += 5

class MageLevelUp(LevelUpStrategy): def apply(self, character): character.health += 10 character.attack += 12 character.defense += 2

class Character: def __init__(self, level_up_strategy: LevelUpStrategy): self.health = 100 self.attack = 10 self.defense = 5 self.level_up_strategy = level_up_strategy

def level_up(self): self.level_up_strategy.apply(self) ```

这样一来，添加新的角色类型就变得非常简单——只需要创建一个新的策略类，而不必修改已有的代码。这就是设计模式的威力。

模式的力量：为什么需要学习设计模式

你可能会问，我已经学会了编程的基本语法，能够写出功能正确的程序，为什么还要学习设计模式？这个问题的答案，可以从以下几个层面来理解。

首先，设计模式是经验的传承。软件开发是一项复杂的智力活动，需要大量的经验积累。但一个人的精力是有限的，不可能亲自经历所有的设计场景。设计模式将前辈们的宝贵经验总结成可复用的知识，你可以站在巨人的肩膀上，用更短的时间掌握更深的技能。正如GoF在书中所说：“设计模式使你可以复用成功的设计和架构。”

其次，设计模式是沟通的桥梁。当你和团队成员讨论设计方案时，如果大家都熟悉设计模式，沟通就会变得高效很多。你不需要画详细的类图、写冗长的文档，只需要说“我们用观察者模式来实现这个功能”，对方立刻就能理解你的意图。设计模式已经成为软件行业的事实标准，是每个专业程序员都应该掌握的行业用语。

第三，设计模式能帮助你写出更好的代码。设计模式不仅仅是一些固定的代码模板，更是一种设计思想。通过学习设计模式，你会逐渐培养出良好的设计直觉，知道什么时候应该把类拆开、什么时候应该合并、什么时候应该使用继承、什么时候应该使用组合。这些决策直接影响代码的质量——是敏捷精悍还是臃肿笨拙，是易于扩展还是难以维护。

第四，设计模式能帮助你理解优秀的开源项目。当今世界有大量的优秀开源软件，如Java的Spring框架、Python的Django框架、JavaScript的React框架等。这些项目大量使用了设计模式，如果你不懂设计模式，就很难理解它们的内部机制，更谈不上贡献代码或进行二次开发。

第五，设计模式能提升你的面试竞争力。在软件工程师的求职面试中，设计模式几乎是必考的知识点。许多面试官会问：“你在项目中用过哪些设计模式？”“为什么选择这个模式而不是那个模式？”“你如何设计一个满足特定需求的系统？”掌握设计模式，能让你在面试中更加从容自信。

面向对象基础：设计模式的基石

设计模式是建立在面向对象程序设计的基础之上的。如果你不熟悉面向对象的基本概念，学习设计模式就会事倍功半。因此，在正式进入设计模式的学习之前，我们需要先回顾一下面向对象的基础知识。

类与对象：概念的抽象

类（Class）是对一类事物的抽象描述，它定义了这类事物所具有的共同特征（属性）和行为（方法）。比如，“狗”就是一个类，它描述了所有狗的共同特征——有四条腿、会叫、会跑，等等。对象（Object）是类的具体实例，“我家的小黄狗”就是“狗”这个类的一个对象。

在程序设计中，类就像是一份蓝图，而对象就是根据这份蓝图建造出来的实际建筑。同一份蓝图可以建造出多栋房子，同一个类也可以创建出多个对象。

```java // Java 示例 public class Dog { // 属性 private String name; private int age;

// 构造方法 public Dog(String name, int age) { this.name = name; this.age = age; }

// 方法 public void bark() { System.out.println(name + "汪汪叫"); }

public void run() { System.out.println(name + "正在跑"); }

// getter和setter public String getName() { return name; }

public void setName(String name) { this.name = name; } }

// 创建对象 Dog myDog = new Dog("小黄", 3); myDog.bark(); // 输出：小黄汪汪叫 ```

封装：信息的保护

封装（Encapsulation）是面向对象的第一大支柱。它的核心思想是将数据和对数据的操作包装在一起，对外只暴露必要的接口，隐藏内部的实现细节。

回到现实世界的例子：一台电视就是封装的一个典型例子。你不需要知道电视内部的电路是如何工作的，只需要知道怎么用遥控器换频道、调音量。电视内部的工作原理被封装了起来，对外只提供了简单的接口（遥控器按钮）。

在程序设计中，封装意味着：

• 将数据（属性）设置为`private`（私有），防止外部直接访问
• 提供公共的方法（getter和setter）来访问和修改数据
• 在方法内部可以添加验证逻辑，确保数据的合法性

```java // 封装示例 public class BankAccount { private double balance; // 余额，私有化

public double getBalance() { return balance; }

public void deposit(double amount) { if (amount > 0) { balance += amount; } }

public void withdraw(double amount) { if (amount > 0 && amount <= balance) { balance -= amount; } } } ```

在这个例子中，`balance`被封装在类的内部，外部代码不能直接修改它。存款和取款操作必须通过`deposit`和`withdraw`方法来进行，而这些方法中可以添加验证逻辑，防止出现负数余额等异常情况。

继承：层次的构建

继承（Inheritance）是面向对象的第二大支柱。它描述的是“是（is-a）”的关系，即子类“是”一种父类。比如，狗是一种动物，所以我们可以说“狗继承自动物”。在程序设计中，通过继承，子类可以复用父类的属性和方法，同时还可以添加自己特有的行为或修改父类的行为。

```ja