备忘录模式与原型模式复习

package com.meran.memento;

public class MementoDemo {
	public static void main(String [] args){
		Memento<String> m=new Memento<String>();
		CareTaker<String> c=new CareTaker<String>(m);
		Originator<String> o=new Originator(c);
		o.insert("插入1");
		o.insert("插入2");
		o.state.display();
		o.creteMemento();
	System.out.println("创建备份点");
		o.insert("插入3");
		o.insert("插入4");
		o.state.display();
		System.out.println("恢复到上一个备份点");
	o.undo();
		o.state.display();
	}

}
class Originator<T>{
	CareTaker<T> taker;
	List<T> state ;
	public Originator(CareTaker<T> taker){
		state=new List<T>();
		this.taker=taker;
	}
	
	public void creteMemento(){
		Memento<T> mem=new Memento<T>();
		mem.setState(state.clone());
		taker.setMemento(mem);
	}
	public void SetState(List<T> state){this.state=state;}
	
	public List<T> getState(){
		return state;
	}
	public void undo(){
		state=taker.mem.getState();
	}
	public void insert(T value){
		state.insert(value);
	}

}
class List<T> implements Cloneable{
	
	Node<T> header;
	public List(){

		header=new Node<T>();
		header.next=header;
	}
	public List(Node<T> node){
		header=node;
		header.next=header;
	}
	public void insert(T value){
		if(header.next==header){
			Node<T> n=new Node<T>(value);
			header.next=n;
			n.next=header;
		
					
		}
		else{
		Node<T> temp=new Node<T>(value);
		Node<T> node=header.next;
		header.next=temp;
		temp.next=node;
		}
	}
	public void display(){
		for(Node<T> n=header.next;n!=header;n=n.next)
			System.out.println(n.value+" ");

	}
	@ Override
	public List<T> clone(){
		List<T> list=new List<T>();
		list.header=new Node<T>();

	  
		Node <T>  temp;
		temp=list.header;
		for(Node<T> n=header.next ;n!=header;n=n.next)
		{   
			
			temp.next=new Node<T>(n.value);
			temp=temp.next;	 
		}
		temp.next=list.header;
		    
		return  list;
	}

	

class Node<T>{
	Node<T> next;
	T value;
	public Node(){
		value=null;
	}
	public Node(T value){
		this.value=value;
		
	}
}
}
class Memento<T>{
	List<T> state;
	public void setState(List<T> state){
		this.state=state;
	}
	public List<T> getState(){
		return state;
	}
	
}
class CareTaker<T>{
    Memento<T> mem;
	
    public CareTaker(Memento<T> mem){
    	this.mem=mem;
    }
	public void setMemento(Memento<T> mem){
		this.mem=mem;
	 	
	}
	public Memento<T> getMemento(){
		return mem;
	}
}

 主要是复习一下模式，顺便回答论坛里的提问。

 

总结一下 备忘录模式

CareTaker

 这个类 主要用来分摊职责 ，他看以看到一个 memento 的窄接口，是用来管理 memento 的，

Originator 主要是备份源， 它提供方法生成 memento  ，用自己现在的状态 ，提供一系列方法给外界访问。

memento 则主要用于存储备份，可以在里面保存一个队列，支持多步骤的的 undo操作。

 

好处是，备份信息可以不暴露给外界， 外界只能看到 一些操作的信息，比如创建备份点，undo 操作

 

涉及到了 原型模式。 这里我覆写了 clone 方法  深复制拉