创建型模式
简单工厂模式(Simple Factory Pattern)
中文介绍：简单工厂模式通过一个工厂类来创建不同类型的对象，而不需要直接调用它们的构造函数。它将对象的创建逻辑封装在工厂类中，根据不同的参数返回相应的对象实例。这种模式提供了一种简单的方式来创建对象，同时封装了实例化的细节。
英文介绍：The Simple Factory pattern creates different types of objects through a factory class without directly calling their constructors. It encapsulates the object creation logic in the factory class and returns the corresponding object instance based on different parameters. This pattern provides a simple way to create objects while encapsulating the instantiation details.
抽象工厂模式(Abstract Factory Pattern)
中文介绍：抽象工厂模式提供了一种方式来创建一组相关或依赖的对象，而无需指定其具体类。它通过定义一个抽象工厂接口和一组具体工厂实现来实现这一目的。这种模式有助于确保一组对象之间的一致性和互操作性。
英文介绍：The Abstract Factory pattern provides a way to create a family of related or dependent objects without specifying their concrete classes. It achieves this by defining an abstract factory interface and a set of concrete factory implementations. This pattern helps ensure consistency and interoperability among a group of objects.
工厂方法模式(Factory Method Pattern)
中文介绍：工厂方法模式通过将对象的创建延迟到子类来解决简单工厂模式中的限制。它定义了一个创建对象的抽象方法，由子类来实现具体的对象创建逻辑。这种模式允许在不修改现有代码的情况下引入新的对象类型，提高了代码的可扩展性。
英文介绍：The Factory Method pattern solves the limitations of the Simple Factory pattern by deferring the object creation to subclasses. It defines an abstract method for creating objects, which is implemented by subclasses with specific object creation logic. This pattern allows introducing new types of objects without modifying existing code, improving code extensibility.
单例模式(Singleton Pattern)
中文介绍：单例模式用于确保一个类只能创建一个对象实例。它通过限制类的实例化过程，使得在程序的任何地方都只能获取到同一个实例。这对于需要共享资源或实现全局访问点的情况非常有用。
英文介绍：The Singleton pattern is used to ensure that a class has only one instance. It restricts the instantiation process of a class, allowing only one instance to be accessed throughout the program. This is useful in situations where a shared resource or a global access point is required.
建造者模式(Builder Pattern)
中文介绍：建造者模式用于创建复杂对象，通过将对象的构建过程分离出来，使得相同的构建过程可以创建不同的表示。它将对象的构建步骤逐步指导给指导者类，从而创建出一个完整的对象。这种模式可以简化对象的构建过程，并提供更好的灵活性。
英文介绍：The Builder pattern is used to create complex objects by separating the construction process from the object's representation. It guides the construction steps of an object to a director class, resulting in the creation of a complete object. This pattern simplifies the object construction process and provides better flexibility.
原型模式(Prototype Pattern)
中文介绍：原型模式用于创建对象的副本，以避免重复创建相似的对象。它通过克隆现有对象来创建新对象，而不是通过调用构造函数。这种模式提供了一种方便的方式来创建对象，同时减少了对象创建的开销。
英文介绍：The Prototype pattern is used to create copies of objects to avoid repetitive creation of similar objects. It creates new objects by cloning existing objects instead of calling constructors. This pattern provides a convenient way to create objects while reducing the overhead of object creation.
结构性模式
适配器模式(Adapter Pattern)
中文介绍：适配器模式将一个类的接口转换成客户端所期望的另一个接口。它允许原本不兼容的接口之间进行合作，通过适配器将其中一个接口转换成另一个接口，使得客户端可以统一调用不同接口的对象。
英文介绍：The Adapter pattern converts the interface of a class into another interface that clients expect. It allows incompatible interfaces to work together by converting one interface into another using an adapter. This enables clients to interact with objects of different interfaces through a unified interface.
桥接模式(Bridge Pattern)
中文介绍：桥接模式将抽象部分和实现部分解耦，使它们可以独立地变化。通过将抽象部分和实现部分分离，桥接模式可以实现更好的灵活性和扩展性。它通过组合关系而不是继承关系来连接抽象和实现部分。
英文介绍：The Bridge pattern decouples the abstraction and implementation parts, allowing them to vary independently. By separating the abstraction and implementation parts, the Bridge pattern achieves better flexibility and extensibility. It connects the abstraction and implementation parts through composition rather than inheritance.
组合模式(Composite Pattern)
中文介绍：组合模式将对象组合成树状结构，以表示部分-整体的层次结构。它使得用户对单个对象和组合对象的使用具有一致性，可以像操作单个对象一样操作组合对象。组合模式可以简化客户端代码，并使得新增组件更加方便。
英文介绍：The Composite pattern combines objects into tree-like structures to represent part-whole hierarchies. It allows users to treat individual objects and composite objects uniformly, enabling operations on composite objects as if they were individual objects. The Composite pattern simplifies client code and makes adding new components more convenient.
装饰器模式(Decorator Pattern)
中文介绍：装饰器模式通过动态地将责任附加到对象上来扩展其功能。它提供了一种灵活的方式来扩展对象的行为，而无需使用子类。装饰器模式通过将对象包装在一个装饰器类中，然后递归地将装饰器叠加在一起，实现了一种动态组合对象的方式。
英文介绍：The Decorator pattern extends the functionality of an object by dynamically attaching responsibilities to it. It provides a flexible way to enhance the behavior of an object without using subclasses. The Decorator pattern achieves this by wrapping objects in decorator classes and recursively stacking decorators, allowing for dynamic composition of objects.
外观模式(Facade Pattern)
中文介绍：外观模式提供了一个统一的接口，用于访问子系统中的一组接口。它将复杂的子系统抽象成一个简单的接口，使得客户端与子系统之间的耦合度降低。外观模式可以简化客户端与子系统的交互，提供了一种简单的方式来使用复杂子系统。
英文介绍：The Facade pattern provides a unified interface to a set of interfaces in a subsystem. It abstracts a complex subsystem into a simple interface, reducing the coupling between the client and the subsystem. The Facade pattern simplifies the interaction between the client and the subsystem, providing a convenient way to use a complex subsystem.
享元模式(Flyweight Pattern)
中文介绍：享元模式将对象的状态分为内部状态和外部状态。内部状态可以被共享，而外部状态取决于具体的场景，因此不可共享。享元模式通过共享内部状态来减少对象的数量，从而减少内存消耗和提高性能。它将共享的部分抽象出来作为享元对象，而将不共享的部分作为外部状态传入享元对象中，以实现对象的共享和复用。
英文介绍：The Flyweight pattern divides an object's state into intrinsic state and extrinsic state. The intrinsic state can be shared, while the extrinsic state depends on the specific context and cannot be shared. The Flyweight pattern reduces the number of objects by sharing the intrinsic state, thereby reducing memory consumption and improving performance. It abstracts the shared part as a flyweight object, while the non-shareable part is passed to the flyweight object as extrinsic state, enabling object sharing and reusability.
代理模式(Proxy Pattern)
中文介绍：代理模式为其他对象提供一个代理，以控制对这个对象的访问。代理对象可以在目标对象的基础上提供额外的功能，例如远程访问、延迟加载等。代理模式通过引入代理对象，实现了对目标对象的间接访问和控制，增强了系统的灵活性和安全性。
英文介绍：The Proxy pattern provides a surrogate or placeholder for another object to control access to it. The proxy object can provide additional functionality on top of the target object, such as remote access, lazy loading, etc. The Proxy pattern introduces a proxy object, enabling indirect access and control of the target object, enhancing system flexibility and security.
行为型模式
责任链模式(Chain of Responsibility Pattern)
中文介绍：责任链模式将请求的发送者和接收者解耦，形成一条请求处理的链。每个处理者都有机会处理请求，或者将请求传递给链中的下一个处理者。这样可以动态地组合处理者，并根据请求的类型将其发送到合适的处理者。责任链模式可以降低发送者和接收者之间的耦合度，提高系统的灵活性和可扩展性。
英文介绍：The Chain of Responsibility pattern decouples the sender of a request from its receivers, forming a chain of request handlers. Each handler has the opportunity to handle the request or pass it to the next handler in the chain. This allows for dynamic composition of handlers and routing the request to the appropriate handler based on its type. The Chain of Responsibility pattern reduces the coupling between senders and receivers, improving system flexibility and extensibility.
命令模式(Command Pattern)
中文介绍：命令模式将请求封装成一个对象，从而使得可以将请求的发送者和请求的接收者解耦。通过将请求封装成对象，可以支持请求的参数化、队列化、撤销和重做等操作。命令模式可以提供更大的灵活性和可扩展性，并支持构建具有复杂交互的命令执行系统。
英文介绍：The Command pattern encapsulates a request as an object, decoupling the sender of the request from its receiver. By encapsulating the request as an object, it allows for parameterizing, queuing, undoing, and redoing of requests. The Command pattern provides greater flexibility and extensibility, enabling the construction of command execution systems with complex interactions.
解释器模式(Interpreter Pattern)
中文介绍：解释器模式定义了一种语言的文法表示，并解析相应的语句。它将一个语言中的表达式表示为一个解释器对象的类层次结构，并提供了一种方式来解释和执行这些语句。解释器模式可以用于构建自定义的领域特定语言（DSL）或实现复杂的语法解析和处理。
英文介绍：The Interpreter pattern defines a representation for a language's grammar and interprets corresponding statements. It represents expressions in a language as a class hierarchy of interpreter objects and provides a way to interpret and execute these statements. The Interpreter pattern can be used to build custom domain-specific languages (DSLs) or implement complex syntax parsing and processing.
迭代器模式(Iterator Pattern)
中文介绍：迭代器模式提供一种统一的方式来访问集合对象中的各个元素，而无需暴露集合的内部表示。它封装了对集合的遍历行为，并提供了一组统一的迭代接口，使得可以按序访问集合中的元素。迭代器模式可以使得集合和迭代算法相互分离，提高代码的可维护性和复用性。
英文介绍：The Iterator pattern provides a unified way to access the elements of a collection object without exposing its internal representation. It encapsulates the traversal behavior of a collection and provides a set of uniform iteration interfaces for sequentially accessing the elements of the collection. The Iterator pattern separates the collection from the iteration algorithm, improving code maintainability and reusability.
中介者模式(Mediator Pattern)
中文介绍：中介者模式定义了一个中介者对象，用于封装一组对象之间的交互。它促进了对象之间的松耦合，通过集中控制对象之间的通讯，减少了对象之间的直接依赖关系。中介者模式可以降低系统的复杂性，提高可维护性和可扩展性。
英文介绍：The Mediator pattern defines a mediator object that encapsulates the interaction among a group of objects. It promotes loose coupling between objects by centralizing the communication between them, reducing direct dependencies between objects. The Mediator pattern reduces system complexity and improves maintainability and extensibility.
备忘录模式(Memento Pattern)
中文介绍：备忘录模式用于捕获一个对象的内部状态，并在需要时恢复对象到之前的状态。它提供了一种方式来保存和恢复对象的状态，而不会暴露对象的实现细节。备忘录模式可以有效地支持撤销和恢复功能，以及实现对象的历史记录和回滚机制。
英文介绍：The Memento pattern is used to capture the internal state of an object and restore it to a previous state when needed. It provides a way to save and restore the state of an object without exposing its implementation details. The Memento pattern effectively supports undo and redo functionality, as well as implementing object history and rollback mechanisms.
观察者模式(Observer Pattern)
中文介绍：观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生变化时，它的所有依赖者都会收到通知并自动更新。观察者模式提供了一种松耦合的方式来设计对象之间的交互，使得可以动态地建立关联关系，增加可扩展性。它常用于事件驱动的系统或需要实时更新的场景。
英文介绍：The Observer pattern defines a one-to-many dependency relationship, where multiple observers are notified and updated automatically when the state of an object changes. The Observer pattern provides a loosely coupled way to design interactions between objects, allowing the dynamic establishment of relationships and increasing extensibility. It is commonly used in event-driven systems or scenarios that require real-time updates.
状态模式(State Pattern)
中文介绍：状态模式允许一个对象在其内部状态发生改变时改变其行为。它将对象的各种状态封装成独立的类，并将对象的行为委托给当前状态对象。通过动态地改变对象的状态类，可以实现对象行为的动态变化，同时避免了大量的条件判断语句。状态模式可以提高代码的可维护性和扩展性。
英文介绍：The State pattern allows an object to alter its behavior when its internal state changes. It encapsulates various states of an object into separate classes and delegates the object's behavior to the current state object. By dynamically changing the state class of an object, it can achieve dynamic behavior changes without the need for extensive conditional statements. The State pattern improves code maintainability and extensibility.
策略模式(Strategy Pattern)
中文介绍：策略模式定义了一系列的算法，并将每个算法封装成独立的策略类。它允许客户端在运行时选择算法，而不是在编译时固定使用某个算法。策略模式可以提供灵活的算法替换和扩展，同时减少了条件判断语句的使用。
英文介绍：The Strategy pattern defines a series of algorithms and encapsulates each algorithm into a separate strategy class. It allows clients to choose algorithms at runtime instead of fixedly using a particular algorithm at compile time. The Strategy pattern provides flexible algorithm substitution and extension while reducing the use of conditional statements.
模板模式(Template Pattern)
中文介绍：模板模式定义了一个操作的算法框架，将某些步骤的具体实现延迟到子类中。它提供了一种结构化的方式来编写可复用的算法，同时允许子类在不改变算法结构的情况下重新定义算法的某些步骤。模板模式可以减少代码的重复，并提高代码的可维护性和扩展性。
英文介绍：The Template pattern defines the skeleton of an operation's algorithm and defers the implementation of certain steps to subclasses. It provides a structured way to write reusable algorithms while allowing subclasses to redefine certain steps of the algorithm without changing its structure. The Template pattern reduces code duplication and improves code maintainability and extensibility.
访问者模式(Visitor Pattern)
中文介绍：访问者模式将算法的操作和数据结构分离，使得可以在不修改数据结构的前提下定义新的操作。它将操作封装成独立的访问者类，这些访问者类可以在不同的数据结构上进行访问。访问者模式可以增加新的操作而无需修改现有的数据结构，提高代码的可扩展性和灵活性。
英文介绍：The Visitor pattern separates the operations on data structures from the data structures themselves, allowing the definition of new operations without modifying the data structures. It encapsulates operations into separate visitor classes that can visit different data structures. The Visitor pattern enables the addition of new operations without modifying existing data structures, improving code extensibility and flexibility.