21备忘录模式Memento

一、什么是备忘录模式

Memento模式也叫备忘录模式,是行为模式之 一,它的作用是保存对象的内部状态,并在需要 的时候(undo/rollback)恢复对象以前的状态。

二、备忘录模式的应用场景

  如果一个对象需要保存状态并可通过undo或rollback等 操作恢复到以前的状态时,可以使用Memento模式。

    1)一个类需要保存它的对象的状态(相当于Originator角色)

    2)设计一个类,该类只是用来保存上述对象的状态(相当于Memento角色)

    3)需要的时候,Caretaker角色要求Originator返回一个Memento并加以保存

    4)undo或rollback操作时,通过Caretaker保存的Memento恢复Originator对象的状态

三、备忘录模式的结构

四、备忘录模式的角色和职责

  Originator(原生者) 需要被保存状态以便恢复的那个对象。

  Memento(备忘录) 该对象由Originator创建,主要用来保存Originator的内部状态。

  Caretaker(管理者) 负责在适当的时间保存/恢复Originator对象的状态。

没使用备忘录模式时

 1 public class Person {
 2     //姓名
 3     private String name;
 4     //性别
 5     private String sex;
 6     //年龄
 7     private int age;
 8
 9     public Person() {
10
11     }
12
13     public Person(String name, String sex, int age) {
14         this.name = name;
15         this.sex = sex;
16         this.age = age;
17     }
18
19     public String getName() {
20         return name;
21     }
22
23     public void setName(String name) {
24         this.name = name;
25     }
26
27     public String getSex() {
28         return sex;
29     }
30
31     public void setSex(String sex) {
32         this.sex = sex;
33     }
34
35     public int getAge() {
36         return age;
37     }
38
39     public void setAge(int age) {
40         this.age = age;
41     }
42
43     public void display() {
44         System.out.println("name:" + name + ",sex:" + sex + ",age:" + age);
45     }
46 }
 1 public class MainClass {
 2     public static void main(String[] args) {
 3         Person per = new Person("lifengxing","男",30);
 4
 5         //保存内部状态(备份)
 6         Person backup = new Person();
 7         backup.setName(per.getName());
 8         backup.setAge(per.getAge());
 9         backup.setSex(per.getSex());
10
11         per.display();
12
13         //修改
14         per.setAge(20);
15         per.display();
16
17         //回滚 还原
18         per.setName(backup.getName());
19         per.setSex(backup.getSex());
20         per.setAge(backup.getAge());
21
22         per.display();
23
24     }
25 }

=======================================================

使用备忘录模式

 1 public class Person {
 2     //姓名
 3     private String name;
 4     //性别
 5     private String sex;
 6     //年龄
 7     private int age;
 8
 9     public Person() {
10
11     }
12
13     public Person(String name, String sex, int age) {
14         this.name = name;
15         this.sex = sex;
16         this.age = age;
17     }
18
19     public String getName() {
20         return name;
21     }
22
23     public void setName(String name) {
24         this.name = name;
25     }
26
27     public String getSex() {
28         return sex;
29     }
30
31     public void setSex(String sex) {
32         this.sex = sex;
33     }
34
35     public int getAge() {
36         return age;
37     }
38
39     public void setAge(int age) {
40         this.age = age;
41     }
42
43     public void display() {
44         System.out.println("name:" + name + ",sex:" + sex + ",age:" + age);
45     }
46
47     //创建一个备份
48     public Memento createMemento() {
49         return new Memento(name,sex,age);
50     }
51
52     //恢复备份,还原
53     public void setMemento(Memento memento) {
54         this.name = memento.getName();
55         this.sex = memento.getSex();
56         this.age =  memento.getAge();
57     }
58 }

备份

 1 //备份
 2 public class Memento {
 3     // 姓名
 4     private String name;
 5     // 性别
 6     private String sex;
 7     // 年龄
 8     private int age;
 9
10     public Memento(String name, String sex, int age) {
11         this.name = name;
12         this.sex = sex;
13         this.age = age;
14     }
15
16     public String getName() {
17         return name;
18     }
19
20     public void setName(String name) {
21         this.name = name;
22     }
23
24     public String getSex() {
25         return sex;
26     }
27
28     public void setSex(String sex) {
29         this.sex = sex;
30     }
31
32     public int getAge() {
33         return age;
34     }
35
36     public void setAge(int age) {
37         this.age = age;
38     }
39 }

看守人

 1 //看守人
 2 public class Caretaker {
 3     private Memento memento;
 4
 5     public Memento getMemento() {
 6         return memento;
 7     }
 8
 9     public void setMemento(Memento memento) {
10         this.memento = memento;
11     }
12 }

测试

 1 public class MainClass {
 2     public static void main(String[] args) {
 3         Person per = new Person("lifengxing","男",24);
 4
 5 //        Memento memento = per.createMemento();
 6         Caretaker caretaker = new Caretaker();
 7         caretaker.setMemento(per.createMemento());
 8
 9         per.display();
10
11         per.setName("beifeng");
12         per.setSex("女");
13         per.setAge(1);
14
15         per.display();
16
17         per.setMemento(caretaker.getMemento());
18         per.display();
19
20     }
21 }

原文地址:https://www.cnblogs.com/justdoitba/p/9034885.html

时间: 2024-08-29 06:36:31

21备忘录模式Memento的相关文章

设计模式之备忘录模式(Memento)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

备忘录模式(Memento Pattern)

备忘录模式(Memento Pattern)用来恢复一个对象的状态到以前的状态. 备忘录模式下属于行为模式的类别. 实现实例 在这个示例中,备忘录模式(Memento Pattern)使用三个操作者类. Memento类中包含要恢复的对象的状态. 创建者在Memento对象中创建和存储状态,Caretaker对象负责从Memento中恢复对象状态.在这个示例中,创建了以下几个类:Memento,Originator和CareTaker. MementoPatternDemo这是一个演示类,它将使

设计模式入门之备忘录模式Memento

//备忘录模式定义: //在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态. //这样以后就可以将该对象恢复到原先保存的状态 //实例:测试两种方案,两种方案在第一阶段的过程是相同的,第二阶段是不同的 //实例代码 //备忘录对象的窄接口 public interface FlowAMockMemento { //空的,所谓窄接口,即只是一个标识作用,它的持有者不可以调用任何它的方法 } //测试流程类 public class FlowAMock { private

设计模式(行为型)之备忘录模式(Memento Pattern)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 阅读前一篇<设计模式(行为型)之中介者模式(Mediator Pattern)>http://blog.csdn.net/yanbober/article/details/45533335 概述 备忘录模式提供了一种状态恢复的实现机制,使得用户可以方便地回到一个特定的历史步骤,当新的状态无

【设计模式】—— 备忘录模式Memento

前言:[模式总览]——————————by xingoo 模式意图 这个模式主要是想通过一个对象来记录对象的某种状态,这样有利于在其他需要的场合进行恢复. 该模式还有跟多可以扩展的地方,比如可以记录多个时间的状态,每个角色都有可以扩展的空间,完全看业务场景而定. 应用场景 1 保存对象某一时刻的状态 2 避免直接暴露接口,破坏封装性 模式结构 Originator 是备忘录的发起者,记录状态的对象 class Originator{ private String state; public Me

[设计模式-行为型]备忘录模式(Memento)

一句话 让某个对象可以取到之前的某个状态值. 概括 解析 MEMENTO-同时跟几个MM聊天时,一定要记清楚刚才跟MM说了些什么话,不然MM发现了会不高兴的哦,幸亏我有个备忘录,刚才与哪个MM说了什么话我都拷贝一份放到备忘录里面保存,这样可以随时察看以前的记录啦. 备忘录模式:备忘录对象是一个用来存储另外一个对象内部状态的快照的对象.备忘录模式的用意是在不破坏封装的条件下,将一个对象的状态捉住,并外部化,存储起来,从而可以在将来合适的时候把这个对象还原到存储起来的状态. 实例 这个实例就以状态值

用最简单的例子理解备忘录模式(Memento Pattern)

简单来说,备忘录模式就是支持回退操作.假设让一个Notepad支持回退操作,如何实现呢? 首先需要一个备忘录类. public class Memento { private string _msg; public Memento(string msg) { _msg = msg; } public string GetText() { return _msg; } } 以上,○ 构造函数在Nodepad每次记录信息的时候调用,Nodepad所记录的信息最终通过该构造函数赋值给了_msg字段.○

[工作中的设计模式]备忘录模式memento

一.模式解析 备忘录对象是一个用来存储另外一个对象内部状态的快照的对象.备忘录模式的用意是在不破坏封装的条件下,将一个对象的状态捕捉(Capture)住,并外部化,存储起来,从而可以在将来合适的时候把这个对象还原到存储起来的状态.备忘录模式常常与命令模式和迭代子模式一同使用. 备忘录模式可以根据客户指令,将相应的对象特有属性进行快照,如果客户要恢复对象,则根据快照提供的特有属性进行还原. 二.模式代码 package memento.patten; /** *备忘录类,同时指定要保存的对象属性

C#面向对象设计之——备忘录模式Memento Pattern(二十三)

一.前言 备忘录模式:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象回复到原先保存的状态. 二.结构图 三.实例代码 using System; using System.Collections.Generic; using System.Text; namespace 备忘录模式 { class Program { static void Main(string[] args) { Originator o = new Originator()