备忘录模式（Memento）----行为笔记

备忘录（Memento）对象：一个用来存储另外一个对象内部状态（信息）的快照的对象

用意：在不破坏 封装 的条件下，捕捉一个对象的状态（信息），并外部化存储起来，从而可以在将来合适的时候把对象还原到存储起来的状态。

 

一、涉及角色：

a) 发起人（Originator）：创建一个含有当前的内部 信息（状态）的 备忘录（Memento）对象。使用备忘录对象存储其内部信息（状态）；

b) 备忘录（Memento）：备忘录存储原 发起人（Originator）对象 的内部状态。

c) 负责人（Caretaker）：负责保存好备忘录，不能对备忘录的内容进行操作或检查。

 

二、备忘录模式优点

         1、有时发起人对象的内部信息（状态）必须保存在发起人对象以处的地方，但是必须要由发起人对象自己读取，使用备忘录可以把复杂的发起人内部信息对其他的对象屏蔽起来，从而可以恰当保持封装的边界。

         2、简化发起人（Originator）类。发起人（Originator）不再需要管理和保存其内部状态的一个个版本，客户端可以自行管理它们所需要的这些状态的版本

         3、当发起人角色的状态改变时，有可能这个状态无效，这时候就可以使用暂时存储起来备忘录将状态复原

缺点：

         如果发起人的状态需要完整存储到备忘录对象中，过于消耗资源

三、故事说明      

STATE—跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有不同，比如你约她今天晚上去看电影，对你没兴趣的MM就会说“有事情啦”，对你不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么？”，已经喜欢上你的MM就会说“几点钟？看完电影再去泡吧怎么样？”，当然你看电影过程中表现良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。

状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。

 

发起人（Originator）

public class Originator {
	private String state;
	
	public void showState(){
		System.out.println(state);
	}
	
	public Memento createMemento(){
		return new Memento(state);		
	}
	
	public void setMememto(Memento memento){
		state = memento.getState();
	}
	
	public String getState() { return state; }
	public void setState(String state) { this.state = state; }
	
}

备忘录对象

public class Memento {
	private String state;

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

	public String getState() {
		return state;
	}

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

负责人对象

public class Caretaker {
	private Memento memento;

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

	public Memento getMemento() {
		return memento;
	}
	
}

 

public class Client {
	public static void main(String[] args) {
		Originator originator = new Originator();
		originator.setState("状态：1");
		originator.showState();
		
		Caretaker caretaker = new Caretaker();
		caretaker.setMemento(originator.createMemento()); //创建备忘录，保存状态
		
		originator.setState("状态：2");
		originator.showState();
		
		originator.setMememto(caretaker.getMemento());
		originator.showState();
	}
}

 

四、多重检查点

         可以存储多个状态，将发起人对象的状态存储到备忘录对象里面，备忘录模式将发起人恢复到所存储的某一个检查点。

         发起人的状态存在于一个Vector对象中，每一个状态都有一个指数 index，叫做检查点指数，

注意：备忘录的构造方法中克隆了传入的stateList，然后将克隆存入备忘内部，非常重要，不然会造成客户端和备忘录对象持有对同一个Vector对象的引用，

 

//发起人对象
public class Originator {
	private Vector stateList;
	private int index;
	
	@SuppressWarnings("rawtypes")
	public Originator(){
		stateList = new Vector();
		index = 0 ;
	}
	
	/*工厂方法,创建备忘录对象*/
	public Memento createMemento(){
		return new Memento(stateList, index);
	}
	/*--将发起人恢复到备忘录对象记录的状态--*/
	public void restoreMemento(Memento memento){
		stateList = memento.getStateList();
		index = memento.getIndex();
	}
	/*--状态的赋值方法--*/
	public void setState(String state){
		this.stateList.add(state);
		index++;
	}
	
	/*--打印状态--*/
	public void printStates(){
		System.out.println("---->状态总数：" + index);
		for (int i = 0; i < stateList.size(); i++) {
			System.out.println(stateList.get(i));
		}
	}
}

 

/*备忘录对象*/
public class Memento {
	private Vector stateList;
	private int index;
	
	public Memento(Vector stateList, int index) {
		this.stateList = (Vector) stateList.clone();	//注意：clone
		this.index = index;
	}

	public Vector getStateList() {  return stateList; }
	public void setStateList(Vector stateList) { this.stateList = stateList; }
	public int getIndex() { return index; }
	public void setIndex(int index) { this.index = index; }
		
}

//负责人对象
public class Caretaker {
	private Originator originator;
	private Vector mementoList = new Vector();
	private int current;
	public Caretaker(Originator originator) {
		this.originator = originator;
	}
	
	/*--创建一个新检查点--*/
	public int createMementor(){
		Memento memento = originator.createMemento();
		mementoList.add(memento);
		return current++;
	}
	/*--将发起人恢复到某个检查点--*/
	public void restoreMemento(int index){
		Memento memento = (Memento) mementoList.get(index);
		originator.restoreMemento(memento);
	}
	/*--将某个检查点删除--*/
	public void removeMemento(int index){
		mementoList.remove(index);
	}
}

public class Client {
	public static void main(String[] args) {
		Originator originator = new Originator();
		Caretaker caretaker = new Caretaker(originator);
		
		originator.setState("状态：0");	//改变状态
		caretaker.createMementor();		//建立一个检查点
		
		originator.setState("状态：1");	//改变状态
		caretaker.createMementor();		//建立一个检查点
		
		originator.setState("状态：2");	//改变状态
		caretaker.createMementor();		//建立一个检查点
		
		originator.printStates();
		System.out.println("---下面是恢复到状态：1----");
		caretaker.restoreMemento(1);
		originator.printStates();
		
		System.out.println("---下面是恢复到状态：2----");
		caretaker.restoreMemento(2);
		originator.printStates();
	}
}

打印的信息

---->状态总数：3
状态：0
状态：1
状态：2

---下面是恢复到状态：1----
---->状态总数：2
状态：0
状态：1

---下面是恢复到状态：2----
---->状态总数：3
状态：0
状态：1
状态：2