笨蛋学设计模式行为型模式-备忘录模式【22】

这篇具有很好参考价值的文章主要介绍了笨蛋学设计模式行为型模式-备忘录模式【22】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

8.9备忘录模式

8.9.1概念

​ 备忘录模式允许在不暴露对象实现细节的情况下捕获和恢复对象的内部状态。通过将对象的状态封装在备忘录对象中,并将备忘录对象保存在一个管理者对象中,可以在需要时回滚到对象之前的状态。

8.9.2场景

​ 在现代办公场景中,备忘录模式可以应用于文档编辑工具中。以Office工具为例,当用户在云文档中进行编辑时,系统会自动将当前的文档内容保存在一个备忘录对象中,并将备忘录对象存储在云端的服务器上。每隔一段时间,系统会判断是否需要保存文档的状态,如果需要,则将当前的备忘录对象保存为一个快照,以便日后恢复文档的状态。

8.9.3优势 / 劣势

  • 提供恢复机制:当用户有需要时,能够比较方便地将数据恢复到某个历史的状态
  • 实现内部封装:除了创建它的发起人之外,其他对象都不能够访问这些状态信息

  • 资源消耗大:若需要保存的内部状态信息过多或者特别频繁是,将会占用比较大的内存资源
  • 难以确定保存时间:当对象的状态发生改变时,需要判断是否需要存储备忘录

8.9.4备忘录模式可分为

  • 发起人Originator:需要还原状态的那个对象,负责创建一个备忘录,并使用备忘录记录当前时刻的内部状态
  • 备忘录Memento:存储发起人对象的内部状态,它可以包含发起人的部分或全部状态信息,但是对外部是不可见的,只有发起人能够访问备忘录对象的状态

备忘录有两个接口,发起人能够通过宽接口访问数据,管理者只能看到窄接口,并将备忘录传递给其他对象

  • 管理者Caretaker:负责存储备忘录对象,但并不了解其内部结构,管理者可以存储多个备忘录对象
  • 客户端:在需要恢复状态时,客户端可以从管理者哪里获取备忘录对象,并将其传递给发起人进行状态的恢复

8.9.5备忘录模式

package com.technologystatck.designpattern.mode.memorandum;

import java.util.ArrayList;
import java.util.List;

public class Memorandum {
    public static void main(String[] args) {
        //创建发起人对象
        Originator originator = new Originator();
        originator.setState("State 1");

        //创建管理者对象
        Caretaker caretaker = new Caretaker();

        //保存当前状态
        caretaker.addMemento(originator.createMemento());
        System.out.println("Current State:"+originator.getState());


        //修改状态
        originator.setState("State 2");
        System.out.println("Current State:"+originator.getState());

        //再次保存当前状态
        caretaker.addMemento(originator.createMemento());

        //恢复到先前状态
        originator.restoreFromMemento(caretaker.getMemento(0));

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

//创建发起人类:可以创建备忘录对象
class Originator{
    //备忘录的状态
    private String state;

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

    //创建备忘录对象
    public Memento createMemento(){
        return new Memento(this.state);
    }
    //通过备忘录对象恢复状态
    public void restoreFromMemento(Memento memento){
        state=memento.getState();
    }
}

//创建备忘录类:保存发起人对象的状态
class Memento{
    private String state;
    //保存发起人的状态
    public Memento(String state){
        this.state=state;
    }
    public String getState(){
        return state;
    }
}

//创建备忘录管理者类:保存备忘录对象
class Caretaker{
    private List<Memento> mementos=new ArrayList<>();

    //添加备忘录对象
    public void addMemento(Memento memento){
        mementos.add(memento);
    }

    //获取备忘录对象
    public Memento getMemento(int index){
        return mementos.get(index);
    }
}

8.9.6实战

8.9.6.1题目描述

小明正在设计一个简单的计数器应用,支持增加(Increment)和减少(Decrement)操作,以及撤销(Undo)和重做(Redo)操作,请你使用备忘录模式帮他实现。

8.9.6.2输入描述

输入包含若干行,每行包含一个字符串,表示计数器应用的操作,操作包括 “Increment”、“Decrement”、“Undo” 和 “Redo”。

8.9.6.3输出描述

对于每个 “Increment” 和 “Decrement” 操作,输出当前计数器的值,计数器数值从0开始 对于每个 “Undo” 操作,输出撤销后的计数器值。 对于每个 “Redo” 操作,输出重做后的计数器值。文章来源地址https://www.toymoban.com/news/detail-823582.html

8.9.6.4代码
package com.technologystatck.designpattern.mode.memorandum;

import java.util.Scanner;
import java.util.Stack;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Counter counter = new Counter();

        //处理计数器应用的输入
        while (scanner.hasNext()) {
            String operation = scanner.next();
            switch (operation) {
                case "Increment":
                    counter.increment();
                    break;
                case "Decrement":
                    counter.decrement();
                    break;
                case "Undo":
                    counter.undo();
                    break;
                case "Redo":
                    counter.redo();
                    break;
            }
            System.out.println(counter.getValue());
        }
    }
}

//备忘录
class Memento {
    //备忘录的状态
    private int value;


    public Memento(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

}

//创建人
class Counter {
    //表示计数器的值
    private int value;
    //撤销操作
    private Stack<Memento> undoStack = new Stack<>();
    //重做操作
    private Stack<Memento> redoStack = new Stack<>();


    //减少计数器的值
    public void increment() {
        //执行撤销操作时,需要清除一些无效的备忘录对象
        //这些备忘录对象失去作用了需要清空
        redoStack.clear();
        //需要将当前状态保存在撤销栈中
        undoStack.push(new Memento(value));
        //计数器的值加1
        value++;
    }

    //增加计数器值
    public void decrement() {
        //执行重做操作时,需要清除一些无效的备忘录对象
        //这些备忘录对象失去作用了需要清空
        redoStack.clear();
        //需要将当前状态保存在撤销栈中
        undoStack.push(new Memento(value));
        //计数器的值加1
        value--;
    }

    /**
     * 当执行撤销或重做的操作时,都会将相关的备忘录对象
     * 移动到另一个栈中,保证了操作的一致性
     */
    //撤销操作
    public void undo() {
        //若撤销栈不为空,则将当前栈顶元素移动到重做栈中,
        //并将当前栈顶元素的值赋给value变量
        if (!undoStack.isEmpty()) {
            redoStack.push(new Memento(value));
            value = undoStack.pop().getValue();
        }
    }

    //重做操作
    public void redo() {
        //若重做栈不为空,则将当前栈顶元素移动到撤销栈中
        //并将当前栈顶元素的值赋给value变量
        if (!redoStack.isEmpty()) {
            undoStack.push(new Memento(value));
            value = redoStack.pop().getValue();
        }
    }

    //获取value值
    public int getValue() {
        return value;
    }
}

8.9.7总结

  • 优点:简化了原始对象的代码结构,支持撤销和恢复操作
  • 总结:将对象的状态使用栈或集合的形式保存起来,当需要撤销或重做时,就记录当前对象的状态,并将栈或集合中的值取出来
  • 场景:适用于需要保证对象内部状态的封装和私有性前提下可以轻松地添加新的备忘录和发起人以此来实现备份

到了这里,关于笨蛋学设计模式行为型模式-备忘录模式【22】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式-备忘录模式

    备忘录模式(Memento Pattern)是计算机科学中的一种行为设计模式。它提供了一种在不破坏封装性的前提下,捕获和恢复对象内部状态的方法。这种模式主要用于在用户需要回滚到对象的某个先前状态时,能够实现状态的还原。 在备忘录模式中,主要涉及到三个角色: Origina

    2024年01月23日
    浏览(49)
  • 设计模式——备忘录模式

    备忘录模式(Memento Pattern)是一种行为型设计模式,它在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样可以在需要时将对象恢复到先前的状态。 发起人(Originator): 是拥有复杂内部状态的对象,它可以创建和恢复备忘录。 备忘录(M

    2024年01月19日
    浏览(43)
  • 《设计模式》备忘录模式

    定义 : 备忘录模式又称为快照模式或者令牌模式, 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态。 属性 行为型 模式。 备忘录模式的角色组成 : Originator(发起人) :负责创建一个 Memento

    2024年02月06日
    浏览(45)
  • Java设计模式-备忘录模式

    一、概述 备忘录模式提供了一种状态恢复的实现机制,使得用户可以方便地回到一个特定的历史步骤,当新的状态无效或者存在问题时,可以使用暂时存储起来的备忘录将状态复原,很多软件都提供了撤销(Undo)操作,如 Word、记事本、Photoshop、IDEA等软件在编辑时按 Ctrl+Z

    2024年01月21日
    浏览(51)
  • 【前端设计模式】之备忘录模式

    设计模式是在软件开发中经过验证的解决问题的方法。它们是从经验中总结出来的,可以帮助我们更好地组织和管理代码,提高代码的可维护性、可扩展性和可重用性。无论是前端还是后端开发,设计模式都扮演着重要的角色。在本专栏中,我们将探索一些常见的前端设计模

    2024年02月05日
    浏览(43)
  • 设计模式(十八)备忘录

    在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样就可以在以后将对象恢复到原先保存的状态。备忘录模式是一种对象行为型模式,其别名为标记(Token)模式。 备忘录模式的核心在于备忘录类以及用于管理备忘录的负责人类的设计,包

    2024年02月04日
    浏览(45)
  • 03-JAVA设计模式-备忘录模式

    Java中的备忘录模式(Memento Pattern)是一种行为型设计模式,它允许在不破坏封装性的前提下捕获一个对象的内部状态,并在该对象之外保存这个状态,以便以后可以将对象恢复到原先保存的状态。 主要角色包括: 发起者(Originator):需要保存和恢复状态的对象。它记录当前

    2024年04月26日
    浏览(44)
  • 《设计模式的艺术》笔记 - 备忘录模式

            备忘录模式在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态。它是一种对象行为模式,别名为Token。 myclass.h myclass.cpp main.cpp         1. 它提供了一种状态恢复的实现机制,使得用户可

    2024年01月24日
    浏览(64)
  • C++ 设计模式之备忘录模式

    【声明】本题目来源于卡码网(题目页面 (kamacoder.com)) 【提示:如果不想看文字介绍,可以直接跳转到C++编码部分】         -- 什么是备忘录模式  (第17种模式)          备忘录模式 (Memento Pattern)是⼀种 ⾏为型设计模式 ,它允许在不暴露对象实现的情况下捕获对

    2024年01月20日
    浏览(50)
  • 设计模式——备忘录模式(Memento Pattern)

    类型: 行为型模式 目的: 保存一个对象的某个状态,以便在适当的时候恢复对象。 使用场景: 1、需要保存/恢复数据的相关状态场景。 2、提供一个可回滚的操作。 2.1.1 定义副本类 2.1.2 定义对象 菜鸟的例子定义Originator 对象的同时,还提供saveStateToMemento、getStateFromMemento的

    2024年02月06日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包