备忘录模式是一种行为设计模式，其核心思想是在不破坏对象封装性的前提下，捕获并保存对象的内部状态

于 2025-05-16 00:00:00 发布
阅读量542 收藏 13
点赞数 13
分类专栏： Array(Python、Java、C++、JS) Sql(SQL Server Database) Character String(STRING) 文章标签： 备忘录模式 设计模式 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blog_programb/article/details/147851492
版权

好的，以下是根据你的描述，使用Python实现备忘录模式的代码示例：

class Memento:
    def __init__(self, state):
        self.state = state

    def get_state(self):
        return self.state


class Originator:
    def __init__(self):
        self.state = None

    def set_state(self, state):
        self.state = state

    def get_state(self):
        return self.state

    def save_state_to_memento(self):
        return Memento(self.state)

    def restore_state_from_memento(self, memento):
        self.state = memento.get_state()


class Caretaker:
    def __init__(self):
        self.memento = None

    def save(self, originator):
        self.memento = originator.save_state_to_memento()

    def restore(self, originator):
        if self.memento:
            originator.restore_state_from_memento(self.memento)

使用示例：

# 创建Originator和Caretaker实例
originator = Originator()
caretaker = Caretaker()

# 设置初始状态
originator.set_state("State1")
print("当前状态:", originator.get_state())

# 保存状态
caretaker.save(originator)

# 修改状态
originator.set_state("State2")
print("修改后的状态:", originator.get_state())

# 恢复状态
caretaker.restore(originator)
print("恢复后的状态:", originator.get_state())

在这个示例中：

  1. Memento类用于存储Originator的状态。
  2. Originator类负责创建和恢复状态，并将状态存储在Memento中。
  3. Caretaker类负责保存和恢复Originator的状态，通过Memento来实现。

通过这种方式，我们实现了备忘录模式，允许用户在需要时将系统恢复到先前的状态。
备忘录模式（Memento Pattern）是一种行为设计模式，它允许在不破坏对象封装性的前提下，捕获并保存对象的内部状态，以便以后可以恢复对象。备忘录模式通常用于实现“撤销”（Undo）功能。它包含以下几个角色：

  1. Originator（发起人）：

    • 负责创建一个备忘录，用以记录当前时刻自身的内部状态。
    • 可以使用备忘录恢复自己的状态。

  2. Memento（备忘录）：

    • 负责存储发起人对象的内部状态。
    • 提供一个接口，用于恢复状态。
    • 它是一个Concrete Memento，用于存储具体的内部状态。

  3. Caretaker（管理者）：

    • 负责保存备忘录。
    • 不对备忘录的内容进行操作或检查。

具体工作流程如下：

  1. 保存状态：

    • 发起人（Originator）在需要保存状态时，创建一个备忘录（Memento）对象，并将当前状态保存到该备忘录中。
    • 发起人将备忘录传递给管理者（Caretaker）。

  2. 存储状态：

    • 管理者（Caretaker）负责存储备忘录对象。管理者可以保存多个备忘录，以便在需要时进行恢复。

  3. 恢复状态：

    • 当需要恢复状态时，发起人（Originator）向管理者（Caretaker）请求一个备忘录。
    • 管理者将备忘录返回给发起人。
    • 发起人使用备忘录中保存的状态来恢复自己的状态。

通过这种方式，备忘录模式可以在不暴露对象内部状态的情况下，保存和恢复对象的状态。这种模式非常适合需要实现“撤销”功能的场景，例如文本编辑器中的撤销操作、图形编辑器中的撤销操作等。

下面是一个简单的代码示例，展示备忘录模式的基本实现：

// Memento interface
interface Memento {
    void setState(String state);
    String getState();
}

// Originator class
class Originator {
    private String state;

    public String getState() {
        return state;
    }

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

    public Memento saveStateToMemento() {
        return new ConcreteMemento(state);
    }

    public void getStateFromMemento(Memento memento) {
        state = memento.getState();
    }
}

// Concrete Memento class
class ConcreteMemento implements Memento {
    private String state;

    public ConcreteMemento(String state) {
        this.state = state;
    }

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

    @Override
    public String getState() {
        return state;
    }
}

// Caretaker class
class Caretaker {
    private Memento memento;

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

    public Memento getMemento() {
        return memento;
    }
}

// Client code
public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        // Initial state
        originator.setState("State1");
        System.out.println("Initial state: " + originator.getState());

        // Save state
        caretaker.saveMemento(originator.saveStateToMemento());

        // Change state
        originator.setState("State2");
        System.out.println("Changed state: " + originator.getState());

        // Restore state
        originator.getStateFromMemento(caretaker.getMemento());
        System.out.println("Restored state: " + originator.getState());
    }
}

在这个示例中，Originator类负责创建和恢复状态，ConcreteMemento类负责存储状态，Caretaker类负责保存和提供备忘录。通过这种方式，可以在需要时恢复对象的状态。
备忘录模式是一种行为设计模式，其核心思想是在不破坏对象封装性的前提下，捕获并保存对象的内部状态，以便后续可以将对象恢复到该状态。以下是备忘录模式在几种常见编程语言中的实现示例。

1. Java 实现

// Memento：存储状态
class Memento {
    private final String state;
    public Memento(String state) { this.state = state; }
    public String getState() { return state; }
}

// Originator：创建并存储状态到 Memento
class Originator {
    private String state;
    public void setState(String state) { this.state = state; }
    public String getState() { return state; }
    public Memento saveStateToMemento() { return new Memento(state); }
    public void restoreStateFromMemento(Memento memento) {
        this.state = memento.getState();
    }
}

// Caretaker：管理 Memento
class Caretaker {
    private Memento memento;
    public void save(Originator originator) {
        memento = originator.saveStateToMemento();
    }
    public void restore(Originator originator) {
        originator.restoreStateFromMemento(memento);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        
        originator.setState("State1");
        System.out.println("当前状态: " + originator.getState());
        
        caretaker.save(originator);
        originator.setState("State2");
        System.out.println("修改后状态: " + originator.getState());
        
        caretaker.restore(originator);
        System.out.println("恢复后状态: " + originator.getState());
    }
}

2. C# 实现

// Memento
public class Memento {
    private readonly string _state;
    public Memento(string state) => _state = state;
    public string GetState() => _state;
}

// Originator
public class Originator {
    private string _state;
    public void SetState(string state) => _state = state;
    public string GetState() => _state;
    public Memento SaveStateToMemento() => new Memento(_state);
    public void RestoreStateFromMemento(Memento memento) => _state = memento.GetState();
}

// Caretaker
public class Caretaker {
    private Memento _memento;
    public void Save(Originator originator) => _memento = originator.SaveStateToMemento();
    public void Restore(Originator originator) => originator.RestoreStateFromMemento(_memento);
}

// 使用示例
class Program {
    static void Main() {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        
        originator.SetState("State1");
        Console.WriteLine("当前状态: " + originator.GetState());
        
        caretaker.Save(originator);
        originator.SetState("State2");
        Console.WriteLine("修改后状态: " + originator.GetState());
        
        caretaker.Restore(originator);
        Console.WriteLine("恢复后状态: " + originator.GetState());
    }
}

3. JavaScript 实现

// Memento
class Memento {
    constructor(state) {
        this.state = state;
    }
    getState() {
        return this.state;
    }
}

// Originator
class Originator {
    constructor() {
        this.state = null;
    }
    setState(state) {
        this.state = state;
    }
    getState() {
        return this.state;
    }
    saveStateToMemento() {
        return new Memento(this.state);
    }
    restoreStateFromMemento(memento) {
        this.state = memento.getState();
    }
}

// Caretaker
class Caretaker {
    constructor() {
        this.memento = null;
    }
    save(originator) {
        this.memento = originator.saveStateToMemento();
    }
    restore(originator) {
        if (this.memento) {
            originator.restoreStateFromMemento(this.memento);
        }
    }
}

// 使用示例
const originator = new Originator();
const caretaker = new Caretaker();

originator.setState("State1");
console.log("当前状态:", originator.getState());

caretaker.save(originator);
originator.setState("State2");
console.log("修改后状态:", originator.getState());

caretaker.restore(originator);
console.log("恢复后状态:", originator.getState());

4. TypeScript 实现

// Memento
class Memento {
    constructor(private state: string) {}
    getState(): string {
        return this.state;
    }
}

// Originator
class Originator {
    private state: string;
    setState(state: string): void {
        this.state = state;
    }
    getState(): string {
        return this.state;
    }
    saveStateToMemento(): Memento {
        return new Memento(this.state);
    }
    restoreStateFromMemento(memento: Memento): void {
        this.state = memento.getState();
    }
}

// Caretaker
class Caretaker {
    private memento: Memento;
    save(originator: Originator): void {
        this.memento = originator.saveStateToMemento();
    }
    restore(originator: Originator): void {
        if (this.memento) {
            originator.restoreStateFromMemento(this.memento);
        }
    }
}

// 使用示例
const originator = new Originator();
const caretaker = new Caretaker();

originator.setState("State1");
console.log("当前状态:", originator.getState());

caretaker.save(originator);
originator.setState("State2");
console.log("修改后状态:", originator.getState());

caretaker.restore(originator);
console.log("恢复后状态:", originator.getState());

关键特点总结

  1. Memento：存储状态的容器，通常提供读取状态的接口，但不允许修改状态。
  2. Originator：创建并管理自身状态，负责生成和恢复 Memento。
  3. Caretaker：负责保存和恢复 Memento，但不直接操作或查看状态内容。

这种模式适用于需要撤销操作、历史记录或版本控制的场景，如文本编辑器的撤销功能、游戏存档等。不同语言的实现方式类似，但语法和面向对象特性（如访问修饰符、类型系统）可能略有差异。
备忘录模式（Memento Pattern）是一种行为设计模式，它允许对象在不破坏封装性的前提下捕获和恢复其内部状态。这种模式在实现撤销操作和恢复状态时非常有用。下面是备忘录模式的一些优缺点：

优点：

  1. 封装性：

    • 备忘录模式通过将对象的状态封装在备忘录对象中，保护了对象的内部状态不被外部直接访问，从而维护了对象的封装性。

  2. 简化了对象状态的保存和恢复：

    • 通过备忘录模式，对象可以轻松地保存和恢复其状态，而不需要外部对象知道状态的具体细节。

  3. 支持撤销操作：

    • 备忘录模式非常适合实现撤销操作，因为它可以保存对象的多个状态，允许用户在不同的状态之间进行切换。

  4. 灵活性：

    • 可以灵活地添加新的备忘录，而不需要修改现有的代码，符合开闭原则。

  5. 减少系统间的耦合：

    • 备忘录模式通过将状态保存和恢复的逻辑与业务逻辑分离，减少了系统各部分之间的耦合。

缺点：

  1. 资源消耗：

    • 如果需要保存的状态非常多或者状态变化频繁，备忘录模式可能会导致大量的内存消耗，因为每个状态都需要被保存。

  2. 复杂性增加：

    • 引入备忘录模式会增加系统的复杂性，需要额外定义和维护备忘录类和管理者类。

  3. 状态管理困难：

    • 在某些情况下，管理大量的备忘录可能会变得复杂，特别是当需要跟踪和维护多个状态时。

  4. 不适合所有场景：

    • 对于不需要频繁保存和恢复状态的应用，使用备忘录模式可能会显得过于复杂和不必要。

  5. 性能问题：

    • 在某些情况下，频繁地创建和销毁备忘录对象可能会影响系统的性能。

总的来说，备忘录模式在需要实现撤销操作和状态恢复的场景中非常有用，但在使用时需要权衡其带来的复杂性和资源消耗。
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bol5261

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值