阅读量:0
创建型模式
单例模式
一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。
以下是使用 PHP 编写的单例模式示例代码：
<?php class Singleton { // 私有静态变量，保存类的唯一实例 private static $instance = null; // 私有构造函数，防止外部通过 new 创建实例 private function __construct() { // 构造方法的代码 } // 公共静态方法，提供获取类实例的访问点 public static function getInstance() { if (self::$instance == null) { // 如果实例不存在，则创建一个实例并将其存储在静态变量中 self::$instance = new Singleton(); } // 返回类的唯一实例 return self::$instance; } // 禁止克隆实例 private function __clone() { // 克隆方法的代码 } // 禁止反序列化实例 private function __wakeup() { // 反序列化方法的代码 } // 这里可以添加其他的方法和属性 } // 使用示例 $singleton1 = Singleton::getInstance(); $singleton2 = Singleton::getInstance(); // 由于单例模式的特性，$singleton1 和 $singleton2 是同一个实例 var_dump($singleton1 === $singleton2); // 输出：bool(true) ?>在这个示例中，`Singleton` 类使用了几个关键技术来实现单例模式：
- **私有静态变量**：`$instance` 用于保存类的唯一实例。
- **私有构造函数**：防止外部通过 `new` 关键字创建类的实例。
- **公共静态方法 `getInstance`**：提供全局访问点来获取类实例。如果实例不存在，
则创建一个实例；如果已存在，则直接返回该实例。
- **私有方法 `__clone` 和 `__wakeup`**：禁止通过克隆和反序列化的方式创建新的实例。
使用单例模式可以确保在整个应用程序中，类的对象只有一个，这在需要全局状态或资源时非常有用。
工厂方法模式
是一种创建型设计模式，它定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类中进行。
以下是使用 PHP 编写的工厂方法模式示例代码：
php
<?php // 产品接口 interface Product { public function doSomething(); } // 实现产品接口的具体产品类 class ConcreteProductA implements Product { public function doSomething() { echo "ConcreteProductA do something.\n"; } } class ConcreteProductB implements Product { public function doSomething() { echo "ConcreteProductB do something.\n"; } } // 工厂接口 interface Factory { public function createProduct(); } // 实现工厂接口的具体工厂类 class ConcreteFactoryA implements Factory { public function createProduct() { return new ConcreteProductA(); } } class ConcreteFactoryB implements Factory { public function createProduct() { return new ConcreteProductB(); } } // 客户端代码 $factoryA = new ConcreteFactoryA(); $productA = $factoryA->createProduct(); $productA->doSomething(); $factoryB = new ConcreteFactoryB(); $productB = $factoryB->createProduct(); $productB->doSomething(); ?>在这个示例中：
Product是一个产品接口，定义了所有产品必须实现的方法doSomething。ConcreteProductA和ConcreteProductB是实现了Product接口的具体产品类。Factory是一个工厂接口，定义了工厂必须实现的方法createProduct。ConcreteFactoryA和ConcreteFactoryB是实现了Factory接口的具体工厂类，分别负责创建ConcreteProductA和ConcreteProductB的实例。- 客户端代码通过创建具体的工厂实例，并调用
createProduct方法来获取产品实例，然后调用产品实例的doSomething方法。
工厂方法模式的好处是：
- 封装性：客户端不需要知道具体的产品是如何创建的，只需要知道如何使用。
- 扩展性：当需要添加新的产品时，只需要添加相应的具体产品类和具体工厂类，无需修改现有代码。
- 解耦：将产品的创建和使用分离，降低了类之间的耦合度。
抽象工厂模式
是一种创建型设计模式，它提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。这种模式通常用于当需要生成多个系列对象时，并且希望这些对象的创建独立于客户端。
以下是使用 PHP 编写的抽象工厂模式示例代码：
php
<?php // 抽象产品 A interface ProductA { public function doSomething(); } // 抽象产品 B interface ProductB { public function doSomething(); } // 具体产品 A1 class ConcreteProductA1 implements ProductA { public function doSomething() { echo "ConcreteProductA1 does something.\n"; } } // 具体产品 B1 class ConcreteProductB1 implements ProductB { public function doSomething() { echo "ConcreteProductB1 does something.\n"; } } // 抽象工厂 interface AbstractFactory { public function createProductA(); public function createProductB(); } // 具体工厂 1 class ConcreteFactory1 implements AbstractFactory { public function createProductA() { return new ConcreteProductA1(); } public function createProductB() { return new ConcreteProductB1(); } } // 客户端代码 $factory = new ConcreteFactory1(); $productA = $factory->createProductA(); $productB = $factory->createProductB(); $productA->doSomething(); $productB->doSomething(); ?>在这个示例中：
ProductA和ProductB是两个抽象产品接口，定义了各自的方法doSomething。ConcreteProductA1和ConcreteProductB1是实现了各自抽象产品接口的具体产品类。AbstractFactory是一个抽象工厂接口，定义了创建所有抽象产品的方法createProductA和createProductB。ConcreteFactory1是实现了AbstractFactory接口的具体工厂类，负责创建ConcreteProductA1和ConcreteProductB1的实例。- 客户端代码通过创建具体工厂的实例，然后调用工厂的
createProductA和createProductB方法来获取具体产品实例，最后调用产品实例的doSomething方法。
抽象工厂模式的好处是：
- 隔离复杂对象的创建和使用：客户端不需要知道具体对象的创建细节，只需要通过工厂接口与具体对象交互。
- 易于扩展：增加一个新的产品系列时，只需要添加相应的具体产品类和具体工厂类，无需修改现有代码。
- 保证产品的一致性：由于具体工厂负责创建一系列相关联或依赖的产品，可以确保客户端使用的产品是协调一致的。
抽象工厂模式适用于对象创建的逻辑复杂且具有多个产品系列时，需要将对象创建的逻辑集中管理，同时保持客户端代码的简洁性和可维护性。
原型模式
是一种创建型设计模式，它允许你复制一个现有的对象，而不是通过实例化类来创建新对象。这种模式特别适用于创建复杂对象或需要大量资源的对象时，因为它可以避免昂贵的构造过程。
以下是使用 PHP 编写的原型模式示例代码：
php
<?php // 定义一个可克隆的类 class Prototype { private $data; public function __construct($data) { $this->data = $data; } public function getData() { return $this->data; } public function setData($data) { $this->data = $data; } // 实现 __clone 方法，用于克隆对象 public function __clone() { // 可以在这里添加一些克隆时需要执行的代码 } } // 客户端代码 $original = new Prototype("原始对象的数据"); // 克隆对象 $cloned = clone $original; // 修改克隆对象的数据 $cloned->setData("克隆对象的新数据"); // 显示原始对象和克隆对象的数据 echo "原始对象数据: " . $original->getData() . "\n"; echo "克隆对象数据: " . $cloned->getData() . "\n";在这个示例中：
Prototype类是一个可克隆的类，它包含一个私有属性$data和相应的 getter 和 setter 方法。Prototype类实现了__clone方法，这个方法在对象被克隆时会被调用。你可以在这里添加一些克隆时需要执行的代码，比如初始化资源或重置状态。- 客户端代码首先创建了一个
Prototype类的实例$original。 - 使用
clone关键字克隆$original对象，创建了一个新的实例$cloned。 - 修改克隆对象
$cloned的数据，显示原始对象和克隆对象的数据。
原型模式的优点包括：
- 简化对象创建过程：通过克隆现有的对象，可以避免复杂的构造过程。
- 提高性能：对于创建复杂对象或需要大量资源的对象，克隆可以显著提高性能。
- 灵活性：可以轻松地修改克隆对象的属性，而不影响原始对象。
原型模式通常用于以下场景：
- 创建新对象的成本较高，或者需要复制的对象初始化很复杂。
- 需要复制的对象是可变对象，即对象的状态可以改变。
- 需要复制的对象是图形或复杂结构的对象，如树形结构。
建造者模式
（Builder Pattern）是一种创建型设计模式，用于构建一个复杂对象，同时允许用户只通过指定复杂对象的类型和内容就能构建它们，隐藏了内部的构建细节。
以下是使用 PHP 编写的建造者模式示例代码：
php
<?php // 产品类 class Product { private $parts = []; public function addPart($part) { $this->parts[] = $part; } public function listParts() { echo "Product parts: \n"; foreach ($this->parts as $part) { echo "- " . $part . "\n"; } } } // 建造者接口 interface Builder { public function addPart1(); public function addPart2(); public function addPart3(); public function getResult(); } // 具体建造者 class ConcreteBuilder implements Builder { private $product; public function __construct() { $this->product = new Product(); } public function addPart1() { $this->product->addPart("Part 1"); } public function addPart2() { $this->product->addPart("Part 2"); } public function addPart3() { $this->product->addPart("Part 3"); } public function getResult() { return $this->product; } } // 导演类 class Director { private $builder; public function setBuilder(Builder $builder) { $this->builder = $builder; } public function construct() { $this->builder->addPart1(); $this->builder->addPart2(); $this->builder->addPart3(); } public function getFinalProduct() { return $this->builder->getResult(); } } // 客户端代码 $builder = new ConcreteBuilder(); $director = new Director(); $director->setBuilder($builder); $director->construct(); $product = $director->getFinalProduct(); $product->listParts();在这个示例中：
Product类是最终要构建的复杂对象。Builder接口定义了用于创建产品的方法。ConcreteBuilder类实现了Builder接口，具体实现了构建步骤。Director类负责使用Builder接口来构建产品，它定义了构建过程的步骤。- 客户端代码创建了
ConcreteBuilder的实例，将其设置给Director，然后调用Director的construct方法来构建产品。最后，它从Director获取最终的产品并展示其组成部分。
建造者模式的优点包括：
- 封装性：创建复杂对象的代码和使用这些对象的代码是分离的。
- 灵活性：可以独立地改变产品的创建过程，同时不影响使用这些产品的对象。
- 可扩展性：添加新的产品创建步骤或创建新的具体建造者类不会影响其他代码。
建造者模式适用于创建复杂对象，且这些对象的创建过程和表示状态是分离的场景。
结构型设计模式
适配器模式
（Adapter Pattern）是一种结构型设计模式，它允许不兼容的接口之间的交互。适配器模式通常用于让现有的类与另一个类兼容，而不是修改现有类源代码。
以下是使用 PHP 编写的适配器模式示例代码：
php
<?php // 目标接口，定义客户端使用的特定领域相关的接口 interface Target { public function request(); } // 客户端代码，依赖于目标接口 class Client { public function doSomethingWithTarget(Target $target) { $target->request(); } } // 适配者类，有一个不兼容的接口 class Adaptee { public function specificRequest() { echo "Doing something specific.\n"; } } // 适配器类，将适配者类转换为目标接口 class Adapter implements Target { private $adaptee; public function __construct(Adaptee $adaptee) { $this->adaptee = $adaptee; } public function request() { $this->adaptee->specificRequest(); } } // 客户端使用适配器模式的示例 $adaptee = new Adaptee(); $adapter = new Adapter($adaptee); $client = new Client(); // 客户端通过适配器使用不兼容的适配者类 $client->doSomethingWithTarget($adapter);在这个示例中：
Target接口定义了客户端使用的特定领域相关的接口。Client类是使用Target接口的客户端代码。Adaptee类有一个不兼容的接口，即specificRequest方法。Adapter类实现了Target接口，并通过构造函数接受一个Adaptee实例。它将Adaptee的specificRequest方法映射到Target接口的request方法。
适配器模式的优点包括：
- 兼容性：允许不兼容的接口之间进行交互。
- 灵活性：可以轻松地添加更多适配器来支持其他不兼容的类。
- 解耦：客户端代码不需要知道适配者类的细节。
适配器模式通常用于以下场景：
- 一个已有的类需要与另一个类协同工作，但是接口不兼容。
- 需要复用一些现有的类，但是不想修改它们的源代码。
- 需要统一多个类的接口，使其可以一起工作。
适配器模式有两种变体：对象适配器和类适配器。上面的示例是一个对象适配器，它使用组合的方式将适配者包装在适配器中。类适配器则使用多重继承（如果语言支持的话）来实现。
桥接模式
（Bridge Pattern）是一种结构型设计模式，用于将抽象部分与其实现部分分离，使它们可以独立地变化。这种模式创建了抽象和实现两个层次，允许在运行时动态地将抽象部分与不同的实现部分绑定在一起。
以下是使用 PHP 编写的桥接模式示例代码：
php
<?php // 抽象类 abstract class Abstraction { protected $implementation; // 在构造函数中接收实现部分 public function __construct(Implementation $implementation) { $this->implementation = $implementation; } // 声明一个方法，允许使用实现部分的方法 abstract public function operation(); } // 扩展抽象类的具体类 class RefinedAbstraction extends Abstraction { public function operation() { echo "RefinedAbstraction: " . $this->implementation->operation() . "\n"; } } // 实现接口 interface Implementation { public function operation(); } // 实现接口的具体类 class ConcreteImplementationA implements Implementation { public function operation() { return "Implementation A"; } } class ConcreteImplementationB implements Implementation { public function operation() { return "Implementation B"; } } // 客户端代码 $implementationA = new ConcreteImplementationA(); $implementationB = new ConcreteImplementationB(); $abstraction = new RefinedAbstraction($implementationA); $abstraction->operation(); // 使用实现 A $abstraction = new RefinedAbstraction($implementationB); $abstraction->operation(); // 切换到实现 B在这个示例中：
Abstraction是一个抽象类，它包含一个对Implementation接口的引用，并定义了一个operation方法。RefinedAbstraction是Abstraction的具体实现，它实现了operation方法，并调用实现部分的operation方法。Implementation是一个实现接口，定义了所有实现类必须实现的operation方法。ConcreteImplementationA和ConcreteImplementationB是实现了Implementation接口的具体类。- 客户端代码创建了实现部分的实例，并将它们传递给
RefinedAbstraction的实例。然后调用operation方法，以展示桥接模式的动态绑定特性。
桥接模式的优点包括：
- 解耦抽象和实现：允许抽象和实现独立地变化。
- 扩展性：可以容易地添加新的实现类，而不需要修改抽象类或客户端代码。
- 复用性：相同的实现可以在不同的抽象类中使用。
桥接模式适用于以下场景：
- 需要将一个类的功能划分为多个独立变化的部分，且希望它们可以独立地进行扩展。
- 需要复用现有的类，但它们不完全符合需求。
- 需要通过动态绑定的方式，将一个抽象与多个实现部分进行组合。
组合模式
（Composite Pattern）是一种结构型设计模式，用于将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式使得用户对单个对象和组合对象的使用具有一致性。
以下是使用 PHP 编写的组合模式示例代码：
php
<?php // 组件接口，定义了所有对象的一致操作方式 interface Component { public function operation(); } // 叶节点，实现组件接口 class Leaf implements Component { private $data; public function __construct($data) { $this->data = $data; } public function operation() { echo "Leaf: " . $this->data . "\n"; } } // 组合节点，也实现组件接口 class Composite implements Component { private $children = []; public function add(Component $child) { $this->children[] = $child; } public function remove(Component $child) { $this->children = array_filter($this->children, function ($c) use ($child) { return $c !== $child; }); } public function operation() { echo "Composite\n"; foreach ($this->children as $child) { $child->operation(); } } } // 客户端代码 $leaf1 = new Leaf("Leaf 1"); $leaf2 = new Leaf("Leaf 2"); $composite1 = new Composite(); $composite2 = new Composite(); $composite1->add($leaf1); $composite1->add($leaf2); $composite2->add($composite1); // 客户端使用组合结构 $composite2->operation();在这个示例中：
Component是一个接口，定义了组合中所有对象的一致操作方式operation。Leaf是一个叶节点类，实现了Component接口。叶节点没有子节点，只包含一些数据。Composite是一个组合节点类，也实现了Component接口。它可以包含子节点，这些子节点可以是叶节点或其他组合节点。Composite类提供了add和remove方法来管理子节点。- 客户端代码创建了一些叶节点和组合节点，将叶节点添加到组合节点中，并调用组合节点的
operation方法来展示组合模式的层次结构。
组合模式的优点包括：
- 透明性：用户不需要知道组合结构内部是叶节点还是组合节点，可以一致地对待它们。
- 灵活性：可以灵活地添加叶节点和组合节点，构建复杂的树形结构。
- 扩展性：可以容易地扩展组合结构，添加新的叶节点和组合节点类型。
组合模式通常用于以下场景：
- 需要表示对象的“部分-整体”层次结构。
- 希望用户对单个对象和组合对象的使用具有一致性。
- 需要能够自由地添加叶节点和组合节点，构建复杂的树形结构。
外观模式
（Facade Pattern）是一种结构型设计模式，它提供了一个统一的高层接口，用于访问子系统中的一群接口。外观模式定义了一个一致的高层接口，让子系统更容易使用。
以下是使用 PHP 编写的外观模式示例代码：
php
<?php // 子系统类 class SubsystemOne { public function operation1() { echo "SubsystemOne: Operation 1\n"; } } class SubsystemTwo { public function operation2() { echo "SubsystemTwo: Operation 2\n"; } } class SubsystemThree { public function operation3() { echo "SubsystemThree: Operation 3\n"; } } // 外观类 class Facade { private $subsystemOne; private $subsystemTwo; private $subsystemThree; public function __construct() { $this->subsystemOne = new SubsystemOne(); $this->subsystemTwo = new SubsystemTwo(); $this->subsystemThree = new SubsystemThree(); } public function operation() { echo "Facade: Starting operation.\n"; $this->subsystemOne->operation1(); $this->subsystemTwo->operation2(); $this->subsystemThree->operation3(); echo "Facade: Finishing operation.\n"; } } // 客户端代码 $facade = new Facade(); $facade->operation();在这个示例中：
SubsystemOne、SubsystemTwo和SubsystemThree是子系统类，每个类都有自己的操作。Facade类是外观类，它提供了一个方法operation，该方法协调子系统中的多个操作。- 外观类的构造函数中创建了所有子系统类的实例，以便在
operation方法中使用。 - 客户端代码通过外观类的
operation方法来访问子系统的操作，而不需要直接与子系统类交互。
外观模式的优点包括：
- 简化接口：为客户端提供了一个简化的接口，隐藏了子系统的复杂性。
- 解耦：客户端与子系统之间通过外观类进行通信，降低了耦合度。
- 易于扩展：添加新的子系统或修改现有子系统的操作，通常不需要修改客户端代码。
外观模式通常用于以下场景：
- 子系统非常复杂或具有多个依赖关系。
- 需要提供一个客户端友好的接口来访问复杂的子系统。
- 希望减少客户端与复杂子系统之间的依赖关系。
代理模式
（Proxy Pattern）是一种结构型设计模式，它为另一个对象提供一个代替或占位符，以控制对它的访问。代理可以在不改变对象的代码的情况下，为对象添加额外的功能操作。
以下是使用 PHP 编写的代理模式示例代码：
php
<?php // 真实主题接口 interface Subject { public function doSomething(); } // 真实主题实现 class RealSubject implements Subject { public function doSomething() { echo "RealSubject is doing something.\n"; } } // 代理类，也实现主题接口 class Proxy implements Subject { private $realSubject; public function __construct() { $this->realSubject = null; } public function doSomething() { if ($this->realSubject === null) { $this->realSubject = new RealSubject(); } // 代理可以在此处添加额外的操作 echo "Proxy: Before real subject do something.\n"; $this->realSubject->doSomething(); echo "Proxy: After real subject do something.\n"; } } // 客户端代码 $proxy = new Proxy(); $proxy->doSomething(); // 通过代理访问真实主题在这个示例中：
Subject是一个接口，定义了代理和真实主题共有的操作。RealSubject是实现了Subject接口的真实主题类。Proxy是代理类，也实现了Subject接口。它包含对RealSubject的引用，并在调用真实主题的方法前后可以添加额外的操作。- 客户端代码通过
Proxy类来访问RealSubject类的方法。
代理模式的优点包括：
- 控制访问：可以在不修改真实主题的情况下，通过代理类控制对真实主题的访问。
- 增加额外操作：可以在代理类中添加额外的逻辑，如访问前的检查、访问后的清理等。
- 提高安全性：可以控制对真实主题的访问权限。
代理模式通常用于以下场景：
- 需要为真实的对象提供一个间接层。
- 需要控制对真实对象的访问，或者在访问时执行额外的操作。
- 需要实现访问控制或延迟初始化。
代理模式有几种变体，如远程代理、虚拟代理、保护代理和智能引用等，每种变体都适用于不同的场景和需求。
享元模式
（Flyweight Pattern）主要用于减少创建对象的数量，通过共享来高效地管理对象。以下是使用 PHP 编写的享元模式示例代码：
php
<?php // 享元接口 interface Flyweight { public function operation($extrinsicState); } // 具体享元类 class ConcreteFlyweight implements Flyweight { private $intrinsicState; // 内部状态，通常由对象所拥有 public function __construct($intrinsicState) { $this->intrinsicState = $intrinsicState; } public function operation($extrinsicState) { // 操作通常涉及内部状态和外部状态 echo "ConcreteFlyweight with intrinsic state {$this->intrinsicState} and extrinsic state $extrinsicState\n"; } } // 享元工厂，用于创建和管理享元对象 class FlyweightFactory { private $flyweights = []; public function getFlyweight($intrinsicState) { if (!isset($this->flyweights[$intrinsicState])) { $this->flyweights[$intrinsicState] = new ConcreteFlyweight($intrinsicState); } return $this->flyweights[$intrinsicState]; } } // 客户端代码 $factory = new FlyweightFactory(); // 获取享元对象，执行操作 $flyweightX = $factory->getFlyweight("intrinsicStateX"); $flyweightY = $factory->getFlyweight("intrinsicStateY"); $flyweightX->operation("extrinsicStateA"); $flyweightY->operation("extrinsicStateB");在这个示例中：
Flyweight是一个接口，定义了享元对象的操作。ConcreteFlyweight是一个具体享元类，实现了Flyweight接口。它具有内部状态（固有状态），这是每个对象唯一的部分。FlyweightFactory是享元工厂类，负责创建和管理享元对象。它使用一个数组来存储已经创建的享元实例，确保每个内部状态只创建一个实例。- 客户端代码通过享元工厂来获取享元对象，并执行操作。
享元模式的关键点在于区分内部状态和外部状态：
- 内部状态：存储在享元对象内部，通常由享元对象所拥有，是对象所固有的。
- 外部状态：通常由客户端提供，通常在享元对象的操作中使用，但是并不存储在享元对象内部。
享元模式适用于对象数量很多，但对象的内部状态可以外部化，并且可以通过传参来改变的场景。这种模式可以显著减少内存消耗，提高程序性能。
装饰模式
（Decorator Pattern）是一种结构型设计模式，允许用户在不改变对象自身的基础上，向一个对象添加新的功能。这种模式通过创建一个包装对象，也就是装饰者，来包裹实际对象。装饰者持有实际对象的实例，并定义一个与实际对象相同的接口。
以下是使用 PHP 编写的装饰模式示例代码：
php
<?php // 抽象组件 interface Component { public function operation(); } // 具体组件 class ConcreteComponent implements Component { public function operation() { echo "ConcreteComponent operation\n"; } } // 抽象装饰者，也实现组件接口 abstract class Decorator implements Component { protected $component; public function __construct(Component $component) { $this->component = $component; } public function operation() { $this->component->operation(); } } // 具体装饰者 A class ConcreteDecoratorA extends Decorator { public function operation() { parent::operation(); echo "ConcreteDecoratorA added behavior\n"; } } // 具体装饰者 B class ConcreteDecoratorB extends Decorator { public function operation() { parent::operation(); echo "ConcreteDecoratorB added behavior\n"; } } // 客户端代码 $simple = new ConcreteComponent(); $simple->operation(); // 使用简单组件 $decoratedA = new ConcreteDecoratorA($simple); $decoratedA->operation(); // 使用装饰后的组件 A $decoratedAB = new ConcreteDecoratorB($decoratedA); $decoratedAB->operation(); // 使用装饰后的组件 A 和 B在这个示例中：
Component是一个接口，定义了可以动态添加职责的对象类型。ConcreteComponent是一个具体组件，实现了Component接口。Decorator是一个抽象装饰者，也实现了Component接口。它持有一个Component类型的成员，这样就可以装饰任何Component类型的对象。ConcreteDecoratorA和ConcreteDecoratorB是具体装饰者类，它们继承自Decorator类，并在operation方法中添加了额外的行为。- 客户端代码演示了如何使用简单组件和装饰后的组件。
装饰模式的优点包括：
- 动态添加职责：可以在运行时添加或修改对象的行为，而不需要修改对象的代码。
- 单一职责：每个装饰者只关注添加一个职责，符合单一职责原则。
- 开闭原则：系统应该对扩展开放，对修改封闭。装饰模式允许扩展新的行为，而不需要修改现有代码。
装饰模式通常用于以下场景：
- 需要动态地给一个对象添加额外的职责。
- 通过继承机制扩展系统功能时，面临类数量急剧增加的问题。
- 需要通过一种无须修改对象自身的情况下，动态地给对象添加职责。
行为设计模式
解释器模式
（Interpreter Pattern）是一种行为型设计模式，用于定义一个语言的文法表示，并构建一个解释器，这个解释器可以用来解释这个语言中的句子。这种模式通常用于解析简单的语言或表达式。
以下是使用 PHP 编写的解释器模式示例代码：
php
<?php // 抽象表达式 abstract class Expression { abstract public function interpret(Context $context); } // 终结符表达式 class TerminalExpression extends Expression { private $data; public function __construct($data) { $this->data = $data; } public function interpret(Context $context) { return $this->data; } } // 非终结符表达式 class NonTerminalExpression extends Expression { private $subExpressions = []; public function addExpression(Expression $expression) { $this->subExpressions[] = $expression; } public function interpret(Context $context) { $result = ''; foreach ($this->subExpressions as $exp) { $result .= $exp->interpret($context); } return $result; } } // 上下文 class Context { // 上下文相关的数据 } // 客户端代码 $terminal = new TerminalExpression('Hello, '); $nonTerminal = new NonTerminalExpression(); $nonTerminal->addExpression($terminal); $nonTerminal->addExpression(new TerminalExpression('World!')); // 创建上下文 $context = new Context(); // 解释表达式 echo $nonTerminal->interpret($context); // 输出: Hello, World!在这个示例中：
Expression是一个抽象表达式类，定义了解释操作的接口interpret。TerminalExpression是终结符表达式类，实现了Expression接口。终结符表达式是文法中的最小单位，通常对应于具体的值或操作。NonTerminalExpression是非终结符表达式类，也实现了Expression接口。非终结符可以包含其他终结符或非终结符表达式。Context是上下文类，包含解释过程中需要的任何全局或环境信息。- 客户端代码创建了终结符和非终结符表达式，并将终结符添加到非终结符中。然后创建一个上下文，并调用非终结符的
interpret方法来解释整个表达式。
解释器模式的优点包括：
- 易于扩展：可以轻松地添加新的行为或文法规则，而不需要修改现有的代码。
- 分离文法和解释器：将文法的定义与解释器的实现分离，使得文法更容易修改和扩展。
解释器模式通常用于以下场景：
- 需要解释一个简单的语言或表达式。
- 需要在运行时从简单的语言或表达式中动态生成代码。
- 需要将一个简单的语言或表达式作为配置或脚本使用。
请注意，解释器模式可能会导致难以维护的复杂系统，特别是当文法非常复杂时。因此，它更适用于简单的文法规则。
解释器模式常用于以下场景：
脚本语言解析：在需要实现简单脚本语言解析的场景，例如在游戏开发中解析游戏AI行为脚本。
配置文件解析：当应用程序需要解析配置文件，而这些配置文件具有某种特定格式或语言时。
领域特定语言（DSL）：在需要定义和解析特定领域语言的场景，比如数据库查询语言、网络配置语言等。
正则表达式匹配：虽然通常使用正则表达式库来处理，但解释器模式可以用来构建复杂的正则表达式解析器。
语法分析：在编译器和解释器的实现中，用于语法分析阶段，将源代码转换为抽象语法树（AST）。
报表语言：在需要解析和执行报表查询语言的场景，例如财务或数据分析软件。
命令行界面（CLI）：构建命令行工具时，用于解析和执行用户输入的命令。
状态机解析：用于解析和执行基于状态机的输入，例如某些协议的通信语言。
文本分析：在文本分析工具中，用于解析文本数据并提取特定格式的信息。
自定义规则引擎：在需要根据自定义规则集进行决策或操作的场景，例如安全策略评估。
解释器模式通过将语言或表达式的每个语法规则表示为一个类，使得扩展新规则变得容易。然而，这种模式可能会导致系统难以理解和维护，特别是当语法规则非常复杂或数量众多时。因此，它更适合用在语法规则相对简单和固定的场景中。
模板方法模式
（Template Method Pattern）是一种行为型设计模式，用于在方法中定义一个算法的骨架，将一些步骤的执行延迟到子类中。这种模式让子类在不改变算法结构的情况下，重新定义算法的某些特定步骤。
以下是使用 PHP 编写的模板方法模式示例代码：
php
<?php // 抽象类，定义了模板方法 abstract class AbstractClass { // 模板方法，定义算法的骨架 final public function templateMethod() { $this->baseOperation1(); $this->baseOperation2(); $this->concreteOperation(); $this->baseOperation3(); } // 基本操作1，由子类实现 abstract protected function baseOperation1(); // 基本操作2，由子类实现 abstract protected function baseOperation2(); // 钩子方法，可以在子类中重写 protected function baseOperation3() { echo "AbstractClass baseOperation3\n"; } // 具体操作，由子类实现 abstract protected function concreteOperation(); } // 具体类1 class ConcreteClass1 extends AbstractClass { protected function baseOperation1() { echo "ConcreteClass1 baseOperation1\n"; } protected function baseOperation2() { echo "ConcreteClass1 baseOperation2\n"; } protected function concreteOperation() { echo "ConcreteClass1 concreteOperation\n"; } public function baseOperation3() { // 重写钩子方法 echo "ConcreteClass1 baseOperation3\n"; } } // 具体类2 class ConcreteClass2 extends AbstractClass { protected function baseOperation1() { echo "ConcreteClass2 baseOperation1\n"; } protected function baseOperation2() { echo "ConcreteClass2 baseOperation2\n"; } protected function concreteOperation() { echo "ConcreteClass2 concreteOperation\n"; } } // 客户端代码 $concreteClass1 = new ConcreteClass1(); $concreteClass1->templateMethod(); $concreteClass2 = new ConcreteClass2(); $concreteClass2->templateMethod();在这个示例中：
AbstractClass是一个抽象类，定义了templateMethod模板方法，该方法按照固定顺序调用基本操作和具体操作。baseOperation1、baseOperation2和concreteOperation是抽象方法，必须在子类中实现。baseOperation3是一个钩子方法，提供了一个默认实现，但可以在子类中重写。ConcreteClass1和ConcreteClass2是具体类，继承自AbstractClass并实现了所有抽象方法。- 客户端代码创建了具体类的实例，并调用了
templateMethod方法来执行算法。
模板方法模式的优点包括：
- 封装不变部分：模板方法封装了算法的不变部分，而将可变部分留给子类实现。
- 扩展性：子类可以扩展或修改算法的特定步骤，而不需要改变算法的结构。
- 代码复用：减少代码重复，提高代码复用性。
模板方法模式通常用于以下场景：
- 需要在多个类中共享相同的算法，但希望在某些步骤中允许不同行为。
- 需要通过子类来扩展或修改算法的特定步骤，但不希望影响其他步骤。
- 需要在保证算法结构不变的同时，提供灵活性和可扩展性。
