掌握软件设计的2023大作业：全面解析设计模式-CSDN博客

本文链接：https://blog.csdn.net/weixin_42181686/article/details/146273590

简介：设计模式是软件工程领域的核心知识，它提供了一套解决开发中常见问题的通用解决方案，并促进了代码的可维护性和可扩展性。本大作业详细讲解并实践了包括工厂模式、单例模式等在内的多种经典设计模式，让开发者能够深入理解每个模式的特点与应用场景，提高软件设计能力，并为职业发展打下坚实基础。设计模式大作业

1. 设计模式概述

设计模式是软件工程领域中的一个核心概念，它代表了在特定环境下针对常见问题的最佳解决方案。本章将深入探讨设计模式的基础概念，解析其理论框架，并分析其在软件开发实践中的应用与重要性。

首先，设计模式是一套被反复验证过的、通用的解决方案模板，能够帮助开发者解决软件开发中的重复问题，提高代码的可维护性和可扩展性。设计模式通常涉及对面向对象设计原则的应用，如单一职责原则、开闭原则、依赖倒置原则等。

设计模式按照其目的和范围大致分为三大类：创建型模式、结构型模式和行为型模式。创建型模式主要用于对象的创建，如工厂模式、单例模式和建造者模式；结构型模式用于组织类和对象以获得更大的结构，例如装饰器模式和代理模式；行为型模式关注对象之间的通信，比如观察者模式和策略模式。

在软件开发过程中，合理运用设计模式不仅能提高代码质量，还能在团队协作中形成共同的语言和认知基础，提升开发效率。本章接下来将详细介绍设计模式的相关知识，并探讨如何在实际开发中有效地应用设计模式。

2. 工厂模式应用与实现

2.1 工厂模式理论基础

2.1.1 工厂模式定义与分类

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种在创建对象时，不暴露创建逻辑给客户端，并且通过使用一个共同的接口来指向新创建的对象的方法。工厂模式被广泛应用于各种应用程序中，用以实现对象的创建和对象之间的解耦。

工厂模式主要有三种类型：

简单工厂模式（Simple Factory） ：也称为静态工厂方法模式。由一个工厂对象决定创建出哪一种产品类的实例。
工厂方法模式（Factory Method） ：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
抽象工厂模式（Abstract Factory） ：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

2.1.2 工厂方法模式和抽象工厂模式的区别

工厂方法模式与抽象工厂模式是两种非常相似的设计模式，但它们的适用场景和复杂度存在区别。

工厂方法模式 着重于创建单一产品的过程，它允许子类决定创建的对象类型。当创建一个产品需要复杂的逻辑时，工厂方法模式是更合适的选择。其优点是可以使得创建过程和使用过程分离，缺点是当增加新的产品时，往往需要增加新的具体工厂类。
抽象工厂模式 则提供了创建一系列相关或相互依赖对象的接口，无需指定它们具体的类。它主要用于创建一系列的对象，这些对象通常是系统中横切多个模块或功能的产品族。抽象工厂模式的缺点在于增加新的产品族比较困难，且当产品族中的产品种类太多时，系统会变得很复杂。

2.2 工厂模式的实现策略

2.2.1 工厂模式的代码实现

以工厂方法模式为例，我们可以用代码块展示如何实现一个工厂类和它的相关产品类。

// 产品接口
public interface Product {
    void use();
}

// 具体产品A
public class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品B
public class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 抽象工厂类
public abstract class AbstractFactory {
    public abstract Product createProduct();
}

// 具体工厂A
public class ConcreteFactoryA extends AbstractFactory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
public class ConcreteFactoryB extends AbstractFactory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    private Product product;

    public Client(AbstractFactory factory) {
        product = factory.createProduct();
    }

    public void useProduct() {
        product.use();
    }
}

// 使用示例
public class FactoryPatternDemo {
    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        Client clientA = new Client(factoryA);
        clientA.useProduct(); // 输出: Using ConcreteProductA

        AbstractFactory factoryB = new ConcreteFactoryB();
        Client clientB = new Client(factoryB);
        clientB.useProduct(); // 输出: Using ConcreteProductB
    }
}

2.2.2 工厂模式在不同编程语言中的实践

工厂模式在不同编程语言中的实现大同小异，但各有特点。例如，在Python中，利用函数或类的特性，可以实现更为简洁的工厂模式。

class ProductA:
    def use(self):
        print("Using ProductA")

class ProductB:
    def use(self):
        print("Using ProductB")

def create_product(product_type):
    if product_type == "A":
        return ProductA()
    elif product_type == "B":
        return ProductB()

# 客户端代码
product = create_product("A")
product.use() # 输出: Using ProductA

在Go中，接口的使用让工厂模式实现更为灵活和类型安全。

package main

import "fmt"

type Product interface {
    Use()
}

type ProductA struct{}

func (p *ProductA) Use() {
    fmt.Println("Using ProductA")
}

type ProductB struct{}

func (p *ProductB) Use() {
    fmt.Println("Using ProductB")
}

func CreateProduct(productType string) Product {
    if productType == "A" {
        return &ProductA{}
    } else if productType == "B" {
        return &ProductB{}
    }
    return nil
}

func main() {
    productA := CreateProduct("A")
    productA.Use() // 输出: Using ProductA
}

工厂模式的实现策略依赖于具体的应用场景和需求，选择合适的实现方式可以有效地提升代码的可维护性和扩展性。

2.3 工厂模式的案例分析

2.3.1 实际项目中工厂模式的应用

在实际的项目开发中，工厂模式的应用场景非常广泛。假设在一个游戏开发项目中，需要创建不同类型的角色对象。此时，工厂模式可以用来封装创建对象的细节，让客户端通过工厂类来创建角色对象，而不是直接实例化具体角色类。

// 角色接口
public interface Character {
    void fight();
}

// 武士类
public class Samurai implements Character {
    public void fight() {
        System.out.println("Samurai is fighting.");
    }
}

// 骑士类
public class Knight implements Character {
    public void fight() {
        System.out.println("Knight is fighting.");
    }
}

// 角色工厂
public class CharacterFactory {
    public Character createCharacter(String characterType) {
        if (characterType == null) {
            return null;
        }
        if (characterType.equalsIgnoreCase("Samurai")) {
            return new Samurai();
        } else if (characterType.equalsIgnoreCase("Knight")) {
            return new Knight();
        }
        return null;
    }
}

// 游戏逻辑类
public class Game {
    private CharacterFactory characterFactory;
    public Game() {
        this.characterFactory = new CharacterFactory();
    }
    public void createCharacterAndFight(String characterType) {
        Character character = characterFactory.createCharacter(characterType);
        if (character != null) {
            character.fight();
        }
    }
}

在这个案例中，游戏逻辑类 Game 通过 CharacterFactory 工厂类创建角色，客户端只需要告诉工厂需要哪种角色，而不需要关心具体的创建过程。

2.3.2 工厂模式在提高代码复用性中的作用

工厂模式不仅封装了创建细节，还提供了一种可以扩展产品族的方式，使得创建的对象可以被复用，同时降低了客户端与具体类的耦合度。

在软件开发中，复用性是提高开发效率和软件质量的重要指标。使用工厂模式可以确保创建逻辑集中管理，当需要引入新的对象类型时，只需添加新的具体类和工厂类，而无需修改现有代码。这样，在保持系统稳定的同时，也使系统更易于维护和扩展。

// 新角色类
public class Wizard implements Character {
    public void fight() {
        System.out.println("Wizard is fighting with magic.");
    }
}

// 新的工厂类
public class NewCharacterFactory extends CharacterFactory {
    public Character createCharacter(String characterType) {
        Character character = super.createCharacter(characterType);
        if (character == null && characterType.equalsIgnoreCase("Wizard")) {
            return new Wizard();
        }
        return character;
    }
}

通过上述简单的修改，新引入的 Wizard 角色可以被复用在游戏中的任何需要魔法战斗的地方。这种灵活的扩展方式正是工厂模式在提高代码复用性中发挥重要作用的体现。

工厂模式是设计模式中的基础之一，其在多种不同场景下都有良好的表现，无论是简单的对象创建还是复杂的产品族管理，工厂模式都能有效地提供解决方案，成为提升代码质量的有力工具。

3. 单例模式应用与实现

3.1 单例模式理论解析

3.1.1 单例模式的概念与特点

单例模式（Singleton Pattern）是一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式的核心思想是，一个类在任何情况下都只会有一个实例存在，任何对这个实例的获取都返回这同一个对象。

单例模式的特点包括：

唯一性 ：确保一个类只有一个实例存在。
全局访问 ：提供全局访问点来获取这个唯一实例。
懒加载 ：单例实例的创建可以是延迟的，即直到第一次使用时才进行实例化。

这种模式通常用于控制资源的访问，比如配置文件管理器、日志记录器、线程池等。单例模式能够避免多个实例引起的资源冲突和管理混乱问题。

3.1.2 单例模式的UML类图分析

在UML（统一建模语言）中，单例模式的类图如下所示：

classDiagram
    class Singleton {
        <<Singleton>>
        +getInstance()~Singleton~
        +Singleton()
    }

上图展示了单例模式的主要组件：

Singleton ：这是单例类，包含一个静态方法 getInstance() 用于获取单例实例，以及一个静态变量 uniqueInstance 用于存储该实例。
+getInstance()~Singleton~ ：这是一个静态方法，客户端通过这个方法获取单例实例。
+Singleton() ：这是单例类的构造函数，它通常是私有的以防止外部通过构造函数创建新的实例。

3.2 单例模式的多种实现方式

3.2.1 懒汉式与饿汉式单例

在单例模式的实现中，最著名的两种方式是懒汉式和饿汉式。

饿汉式 ：在类加载时立即初始化单例对象。这种方式简单且线程安全，但是可能造成不必要的资源浪费。
懒汉式 ：在第一次调用 getInstance() 方法时，才初始化单例对象。这种方式延迟了实例的创建，节省资源，但需要处理线程同步问题。

3.2.2 多线程环境下的单例实现

在多线程环境中，单例模式的实现需要特别注意线程安全问题。可以通过同步代码块、同步方法或双重检查锁定（Double-Checked Locking）来实现线程安全的单例模式。

以下是一个使用双重检查锁定的懒汉式单例模式的示例代码：

public class Singleton {
    private volatile static Singleton uniqueInstance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

这段代码使用了双重检查锁定模式。这里， uniqueInstance 被声明为 volatile ，这确保了 uniqueInstance 在被多个线程访问时，能够被正确的初始化。这是因为在 volatile 变量的读/写操作是原子的，不会发生指令重排序。

3.3 单例模式的优缺点及适用场景

3.3.1 单例模式的优缺点

优点：

全局访问点 ：提供了全局访问点，简化了访问。
控制资源的使用 ：单例模式能够控制资源的使用，避免资源冲突。
减少内存开销 ：由于只有一个实例，可以减少内存开销。

缺点：

依赖于特定的环境 ：在多线程环境下需要考虑线程安全问题。
难以扩展 ：单例类通常难以扩展。
测试困难 ：单例类的实例化依赖于外部环境，这可能导致在测试时的困难。

3.3.2 单例模式的适用场景分析

单例模式的适用场景包括：

全局配置管理 ：当应用程序需要访问一个共享资源时，比如数据库连接器或配置文件。
单点登录系统 ：需要实现一个单一登录点的系统，比如用户登录系统。
无状态对象 ：对于无状态的对象，使用单例模式是非常合适的，例如计数器等。

不过，由于单例模式的一些限制，其在现代应用架构中，尤其是微服务架构中，可能不如其他设计模式（如服务工厂、依赖注入）那么常用。因此，在决定使用单例模式时，应当仔细考虑其适用性和潜在的负面影响。

4. 装饰器模式应用与实现

4.1 装饰器模式基本概念

4.1.1 装饰器模式的定义

装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许用户在不改变对象的接口的情况下，动态地为对象添加新的功能。这种模式通过将原有的对象实例包装在一个新的类中，并在这个新类中添加所需的新行为或特性，实现了原有功能的扩展而不修改原有代码。

装饰器模式包含以下几个关键角色： - 抽象构件（Component）：定义一个对象接口，可以给这些对象动态地添加职责。 - 具体构件（Concrete Component）：定义了一个具体的对象，也可以给这个对象添加一些职责。 - 装饰者（Decorator）：维持一个指向构件对象的引用，并实现与抽象构件相同的接口。 - 具体装饰者（Concrete Decorator）：负责给构件对象添加新的职责。

4.1.2 装饰器模式的结构和工作原理

装饰器模式的工作原理基于递归组合和继承机制。一个装饰者类在运行时可以动态地添加职责，具体是通过在构造函数中接收一个对象，并在该装饰者的任何方法中调用该对象的方法来实现的。

装饰器模式的结构图如下：

classDiagram
      class Component {
          <<interface>>
          +operation() void
      }
      class ConcreteComponent {
          +operation() void
      }
      class Decorator {
          -component: Component
          +operation() void
      }
      class ConcreteDecoratorA {
          +operation() void
          +addedBehavior() void
      }
      class ConcreteDecoratorB {
          +operation() void
          +addedBehavior() void
      }
      Component <|-- Decorator
      Component <|-- ConcreteComponent
      Decorator <|-- ConcreteDecoratorA
      Decorator <|-- ConcreteDecoratorB
      ConcreteDecoratorA <|-- ConcreteComponent
      ConcreteDecoratorB <|-- ConcreteComponent

在这个结构中， Decorator 类在实现 Component 接口的同时，还持有一个 Component 类型的对象。通过在 Decorator 类的 operation 方法中调用持有的 component 的 operation 方法，实现了功能的扩展。具体装饰者 ConcreteDecoratorA 和 ConcreteDecoratorB 添加了额外的职责。

4.2 装饰器模式的实现技巧

4.2.1 装饰器模式的代码实现

以下是使用 Python 语言实现装饰器模式的一个简单例子：

class Component:
    def operation(self):
        raise NotImplementedError("Subclasses must implement this method")

class ConcreteComponent(Component):
    def operation(self):
        print("ConcreteComponent operation")

class Decorator(Component):
    def __init__(self, component: Component):
        self._component = component
    def operation(self):
        self._component.operation()
class ConcreteDecoratorA(Decorator):
    def operation(self):
        super().operation()
        self.addedBehavior()
    def addedBehavior(self):
        print("ConcreteDecoratorA added behavior")
class ConcreteDecoratorB(Decorator):
    def operation(self):
        super().operation()
        self.addedBehavior()
    def addedBehavior(self):
        print("ConcreteDecoratorB added behavior")

# 使用装饰器模式
component = ConcreteComponent()
decorated_component = ConcreteDecoratorA(ConcreteDecoratorB(component))
decorated_component.operation()

在上述代码中， ConcreteComponent 是具体的构件类， Decorator 是装饰器的抽象类， ConcreteDecoratorA 和 ConcreteDecoratorB 是具体的装饰器类，它们在 operation 方法中调用了父类的 operation 方法，并添加了额外的行为。

4.2.2 装饰器模式与其他设计模式的关系

装饰器模式与代理模式类似，都可以用来包装一个对象。但是，代理模式的目的是控制对象的访问，而装饰器模式的目的是在不修改原有对象代码的情况下添加新行为。

装饰器模式与适配器模式也不同。适配器模式主要用于将一个类的接口转换成客户期望的另一个接口，目的是兼容不同的接口；而装饰器模式的目的是为对象添加新功能。

4.3 装饰器模式的实际应用

4.3.1 装饰器模式在日志系统中的应用实例

装饰器模式在日志系统中应用广泛。例如，可以创建一个日志装饰器来为任何组件添加日志功能。每当组件中的 operation 方法被调用时，装饰器将记录相关的日志信息。

4.3.2 装饰器模式在性能优化中的作用

在性能优化方面，装饰器可以用来实现缓存机制。例如，在Web应用中，可以创建一个缓存装饰器，当组件的 operation 方法被调用时，装饰器首先检查结果是否已缓存，如果是，则直接返回缓存结果，否则执行 operation 方法并将结果存入缓存。

装饰器模式使得在保持原有对象接口不变的情况下，能够灵活地对功能进行增强和优化，这使得它在软件开发中有着广泛的应用场景。

5. 命令模式应用与实现

5.1 命令模式核心概念

5.1.1 命令模式的定义和组成

命令模式（Command Pattern）属于行为型设计模式，其核心思想是将请求封装为对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。命令模式可以将“发出请求的对象”与“执行请求的对象”解耦。

命令模式通常包含以下几个关键角色：

Command（命令接口） ：定义执行操作的接口。
ConcreteCommand（具体命令） ：将一个接收者对象绑定于一个动作；调用接收者相应的操作，以实现 Execute。
Client（调用者） ：创建一个具体命令对象并设定它的接收者。
Receiver（接收者） ：知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者。
Invoker（请求者） ：持有一个命令对象，并在某个时间点调用命令对象的 Execute 方法。

5.1.2 命令模式与其他模式的比较

在设计模式的大家族中，命令模式与策略模式、状态模式、职责链模式等其他模式有着相似之处，但也有明显区别：

与策略模式的比较 ：策略模式定义一系列的算法，把它们一个个封装起来，并使它们可相互替换。命令模式的意图是将操作封装成对象，而策略模式的意图是封装算法本身。
与状态模式的比较 ：状态模式允许一个对象在其内部状态改变时改变它的行为。命令模式与状态模式的相似之处在于它们都封装了行为，不同在于命令模式通常关注将行为封装成命令对象，而状态模式关注将状态变化封装成对象。
与职责链模式的比较 ：职责链模式是一种行为设计模式，允许将请求沿着处理者链传递，直到有一个对象处理它为止。命令模式可以用来实现职责链模式，但是职责链模式的目的是解耦请求的发送者和接收者，而命令模式更专注于封装和传递请求。

5.2 命令模式的实现技术

5.2.1 命令模式的代码实现要点

在实现命令模式时，重点在于将请求封装为对象，并让这些对象能够通过接口来调用。这里提供一个简单的命令模式实现的代码示例：

// 命令接口
public interface Command {
    void execute();
}

// 具体命令，例如：HelloWorldCommand
public class HelloWorldCommand implements Command {
    private Receiver receiver;
    public HelloWorldCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        receiver.receive();
    }
}

// 接收者
public class Receiver {
    public void receive() {
        System.out.println("Hello World!");
    }
}

// 发起者
public class Invoker {
    private Command command;
    public void setCommand(Command command) {
        this.command = command;
    }
    public void executeCommand() {
        command.execute();
    }
}

在这个例子中，我们定义了一个 Command 接口，实现了具体的命令 HelloWorldCommand ，以及 Receiver 和 Invoker 。 Invoker 在合适的时机调用 command.execute() 来执行命令。

5.2.2 命令模式在不同编程语言中的实现

命令模式在不同的编程语言中实现时，其核心思想不变，但语法和结构可能会有所不同。例如在Python中，可以使用函数或方法引用作为命令，而无需显式定义接口和实现类：

class Receiver:
    def receive(self):
        print("Hello World!")

class Command:
    def __init__(self, func, *args):
        self.func = func
        self.args = args
    def execute(self):
        self.func(*self.args)

class Invoker:
    def __init__(self):
        self.commands = []

    def store_command(self, command):
        self.commands.append(command)

    def execute_commands(self):
        for command in self.commands:
            command.execute()

# 使用例子
receiver = Receiver()
hello_command = Command(receiver.receive)
invoker = Invoker()
invoker.store_command(hello_command)
invoker.execute_commands()

5.3 命令模式在实际软件开发中的应用

5.3.1 命令模式在GUI编程中的应用

在图形用户界面（GUI）编程中，命令模式经常被用来实现菜单项、按钮和工具栏项的操作。当用户点击一个按钮时，GUI框架实际上执行了一个命令对象。例如，在Qt框架中，按钮的点击事件会触发一个槽函数，该函数实际上就是一个命令对象的执行方法。

5.3.2 命令模式在业务逻辑处理中的优势

在业务逻辑处理中，命令模式可以灵活应对需求变化。通过命令模式可以将复杂操作封装成命令对象，这样就可以将这些对象存储在历史记录中，提供撤销、重做功能。同时，命令模式使得对命令进行排队、日志记录和事务处理成为可能。此外，由于命令对象是独立的，它们可以被多个对象重用，从而减少代码量并提高代码复用性。

// 使用命令模式实现的撤销操作
public class CommandHistory {
    private Stack<Command> executedCommands = new Stack<>();

    public void push(Command cmd) {
        executedCommands.push(cmd);
    }

    public Command pop() {
        return executedCommands.pop();
    }

    public void clear() {
        executedCommands.clear();
    }
}

// 业务逻辑中的撤销功能实现
public class Editor {
    private CommandHistory history = new CommandHistory();

    public void addCommand(Command cmd) {
        history.push(cmd);
    }

    public void undo() {
        Command cmd = history.pop();
        cmd.undo();
    }
}

// 修正后的命令接口，包含撤销方法
public interface Command {
    void execute();
    void undo();
}

在这个例子中，我们利用了命令历史来记录已经执行过的命令，通过调用命令对象的 undo 方法来实现撤销功能。这为业务逻辑处理提供了灵活性和强大的功能支持。

命令模式因其灵活性和高内聚性，在软件开发中被广泛应用，特别是在需要操作封装、命令排队、日志记录、事务处理以及支持撤销和重做的场景中，命令模式提供了一种优雅的解决方案。通过深入理解命令模式及其在各种编程语言中的实现，开发者能够更好地利用这一设计模式来提高代码质量，增强软件系统的可维护性和扩展性。

6. 备忘录模式应用与实现

备忘录模式是一种行为设计模式，它允许在不破坏对象封装的前提下捕获和外部化对象的内部状态，以便之后可以将对象恢复到原先的状态。这种模式经常用于开发中，以实现状态的保存和撤销功能。

6.1 备忘录模式理论介绍

6.1.1 备忘录模式的定义和作用

备忘录模式（Memento Pattern）通常由三个角色组成：发起者（Originator）、备忘录（Memento）和看护者（Caretaker）。发起者是需要保存状态的业务对象。备忘录是一个用来存储发起者内部状态的快照。看护者负责管理备忘录，但它不能访问备忘录内容，从而确保了封装性。

该模式的作用是通过捕获对象的状态，并在将来某个时间点恢复该状态，从而达到撤销或回滚的效果。

6.1.2 备忘录模式的结构和关键概念

备忘录模式的结构通常包含以下几个关键组件：

发起者（Originator） ：它创建一个备忘录对象，并将当前状态存储在其中。
备忘录（Memento） ：负责存储发起者的内部状态，通常提供有限的接口以防止其他对象访问状态。
看护者（Caretaker） ：负责管理备忘录对象，但不直接访问其内容。

在备忘录模式中，发起者与备忘录之间的关系是关键。备忘录提供了一个访问接口，但这个接口的实现细节对于看护者来说是不透明的。

6.2 备忘录模式的实现方法

6.2.1 备忘录模式的关键代码实现

以下是一个简单的备忘录模式的代码实现：

// Originator类
class Originator {
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public Memento createMemento() {
        return new Memento(state);
    }

    public void setMemento(Memento m) {
        this.state = m.getState();
    }

    public String getState() {
        return state;
    }
}

// Memento类
class Memento {
    private String state;

    public Memento(String stateToSave) {
        this.state = stateToSave;
    }

    public String getState() {
        return state;
    }
}

// Caretaker类
class Caretaker {
    private Memento memento;

    public void setMemento(Memento m) {
        this.memento = m;
    }

    public Memento getMemento() {
        return memento;
    }
}

// 客户端代码
public class MementoPatternDemo {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        originator.setState("State1");
        originator.setState("State2");
        caretaker.setMemento(originator.createMemento());

        originator.setState("State3");
        System.out.println("Current State: " + originator.getState());

        originator.setMemento(caretaker.getMemento());
        System.out.println("Restored State: " + originator.getState());
    }
}

在这个例子中， Originator 类负责创建和设置备忘录对象，并且可以恢复状态。 Caretaker 类持有备忘录对象的引用，但不能修改其中的状态。客户端代码演示了如何使用备忘录模式进行状态的保存和恢复。