本文转自：http://blog.csdn.net/liqj2ee/article/details/315619
////////////////////////////////////////////////////////////////////
创建模式
////////////////////////////////////////////////////////////////////
//FactoryMethod模式的例子
package pattern.a.factoryMethod;
interface Product {
void operation();
}
class ConProduct1 implements Product {
//不同的实现可以有不同的产品操作
public void operation() {}
}
class ConProduct2 implements Product {
//不同的实现可以有不同的产品操作
public void operation() {}
}
interface Factory {
Product CreateProduct();
void operation1();
}
class ConFactory1 implements Factory {
//不同的实体场类 在创建产品是可以有不能的创建方法
public Product CreateProduct() {
Product product = new ConProduct1();
operation1();
return product;
}
public void operation1() {}
public static Factory getFactory() {
return new ConFactory1();
}
}
class ConFactory2 implements Factory {
//不同的实体场类 在创建产品是可以有不能的创建方法
public Product CreateProduct() {
Product product = new ConProduct2();
operation1();
return product;
}
public void operation1() {}
//
public static Factory getFactory() {
return new ConFactory2();
}
}
public class FactoryMethod {
public static void main(String[] args) {
Factory factory = ConFactory1.getFactory();
Product product = factory.CreateProduct();
product.operation();
}
}
***********************************************************************
//AbstractoryFactory模式的例子
//我觉得这个模式与FactoryMethod 就是创建产品的数量上有区别
package pattern.a.abstractfactory;
//产品A的接口和实现
interface ProductA {}
class ProductA1 implements ProductA {}
class PorductA2 implements ProductA {}
//产品B的接口和实现
interface ProductB {}
class ProductB1 implements ProductB {}
class ProductB2 implements ProductB {}
//工程和工厂的实现
interface Factory {
ProductA CreateA();
ProductB CreateB();
}
//1工厂产生1系列产品
class ConFactory1 implements Factory {
public ProductA CreateA() {
return new ProductA1();
}
public ProductB CreateB() {
return new ProductB1();
}
}
//2工厂产生2系列产品
class ConFactory2 implements Factory {
public ProductA CreateA() {
return new PorductA2();
}
public ProductB CreateB() {
return new ProductB2();
}
}
class ConFactory {}
public class AbstractFactory {
public static void main(String[] args) {
//1工厂产生1类产品
Factory factory1 = new ConFactory1();
ProductA a1 = factory1.CreateA();
ProductB b1 = factory1.CreateB();
//2工厂产生2类产品
Factory factory2 = new ConFactory1();
ProductA a2 = factory2.CreateA();
ProductB b2 = factory2.CreateB();
}
}
***********************************************************************
//Builder模式的例子
// 模式的宗旨是 将部件创建的细节 和部件的组装方法分离!!! 考兄弟悟性要高
package pattern.a.builder;
class director {
//construct 中存放着组装部件的逻辑 注意 逻辑的分离
public Product construct(Builder builder) {
builder.buildPart1();
builder.buildPart2();
operation();
Product product = builder.retrieveProduct();
return product;
}
public void operation() {}
}
class Product {}
interface Builder {
void buildPart1();
void buildPart2();
Product retrieveProduct();
}
class ConBuilder1 implements Builder {
public void buildPart1() {}
public void buildPart2() {}
public Product retrieveProduct() {
return null;
}
}
class ConBuilder2 implements Builder {
public void buildPart1() {}
public void buildPart2() {}
public Product retrieveProduct() {
return null;
}
}
public class BuilderPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Singleton模式例子
package pattern.a.singleton;
// 一种简单的形式
class SingletonExample {
private static SingletonExample instance;
private SingletonExample() {}
public static SingletonExample getInstance() {
if (instance == null) {
instance = new SingletonExample();
}
return instance;
}
synchronized public static SingletonExample getInstance1() {
if (instance == null) {
instance = new SingletonExample();
}
return instance;
}
public static SingletonExample getInstance2() {
synchronized(SingletonExample.class) {
if (instance == null) {
instance = new SingletonExample();
}
}
return instance;
}
}
//利用类加载时 初始化只产生一次
class SingletonExample2 {
private static SingletonExample2 instance = new SingletonExample2();
private SingletonExample2() {}
public static SingletonExample2 getInstance() {
return instance;
}
}
public class SingletonPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Prototype模式例子
package pattern.a.prototype;
interface Prototype {
Prototype myclone();
}
class ConPrototype1 implements Prototype{
private String a;
public ConPrototype1(String a) {
this.a = a;
}
public Prototype myclone() {
return new ConPrototype1(a);
}
}
class ConPrototype2 implements Prototype{
private int b;
public ConPrototype2(int b) {
this.b = b;
}
public Prototype myclone() {
return new ConPrototype2(b);
}
}
public class PrototypePattern {
public static void main(String[] args) {
Prototype inst1 = new ConPrototype1("testStr1");
Prototype inst2 = null;
inst2 = inst1.myclone();
}
}
***********************************************************************
////////////////////////////////////////////////////////////////////
结构模式
////////////////////////////////////////////////////////////////////
//Adapter模式的例子
package pattern.b.Adapter;
// 类适配
interface Target1 {
void request();
}
class Adaptee1 {
public void specRequest() {}
}
class Adapter1 extends Adaptee1 implements Target1 {
public void request() {
super.specRequest();
}
}
//对象适配
interface Target2 {
void request();
}
class Adaptee2 {
public void specRequest() {}
}
class Adapter2 implements Target2 {
private Adaptee2 adaptee;
public Adapter2(Adaptee2 adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specRequest();
}
}
public class AdapterPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Proxy模式例子
package pattern.b.proxy;
interface Subject {
void request();
}
//真正处理请求的地方
class RealSubject implements Subject {
public void request() {
System.out.println("real access");
}
}
//ProxySubject是与用户交互的类 他是REalSubject的代理
//在处理功能之上的一层 这里可以做前操作 后操作 例如可以验证是否处理请求。
class ProxySubject implements Subject {
private RealSubject real;
public ProxySubject(RealSubject real) {
this.real = real;
}
//
public void request() {
preRequest();
real.request();
afterRequest();
}
private void preRequest() {}
private void afterRequest() {}
}
//java自身提供代理类使用反射机制
public class ProxyPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Composite 模式例子
//在用户的角度 并不知道 不见是单独的还是符合的 只要调用接口级方法 operation
package pattern.b.composite;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
// 安全模式 在接口级只提供部分功能 leaf 和 composite 有不同的功能
interface Component1 {
public void operation();
}
class leaf1 implements Component1 {
public void operation() {
System.out.println("this is the leaf1");
}
}
class Composite1 implements Component1 {
private List components;
public Composite1() {
components = new ArrayList();
}
public void operation() {
Iterator it = components.iterator();
Component1 com = null;
while (it.hasNext()) {
com = (Component1) it.next();
com.operation();
}
}
public void addComponent(Component1 com) {
components.add(com);
}
public void removeComponent(int index) {
components.remove(index);
}
}
// 透明模式 接口定义全部功能 leaf中可能使用空方法或抛出异常 活着写一层 抽象类 写上默认实现方法(极端情况下 是空或异常)
interface Component2 {
public void operation();
public void addComponent(Component2 com);
public void removeComponent(int index);
}
class leaf2 implements Component2 {
public void operation() {
System.out.println("this is the leaf1");
}
//这个使用空方法
public void addComponent(Component2 com) {}
//这个使用不支持异常
public void removeComponent(int index){
throw new UnsupportedOperationException();
}
}
class Composite2 implements Component2 {
private List components;
public Composite2() {
components = new ArrayList();
}
public void operation() {
Iterator it = components.iterator();
Component2 com = null;
while (it.hasNext()) {
com = (Component2) it.next();
com.operation();
}
}
public void addComponent(Component2 com) {
components.add(com);
}
public void removeComponent(int index) {
components.remove(index);
}
}
//也可以用一个抽象类
abstract class AbstractComponent implements Component2{
public void operation() {}
public void addComponent(Component2 com) {}
abstract public void removeComponent(int index);
}
public class CompositePattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Flywight 模式例子
// 将共同的跟不同的属性分离 共享共同属性 而不同属性由外部传入 进行特定操作
package pattern.b.flyweight;
import java.util.HashMap;
import java.util.Map;
// 1没有办法通过obj.value方式 2没有改变属性的方法 3不能通过继承重置属性 所以这个对象是 immutable 不可变的
final class State {
private String value = null;
public State(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
interface Flyweight {
void operation(String extrinsicState);
}
class ConFlyweight1 implements Flyweight {
//state 表示享元的内部状态
//或者用构造函数传入
private State state = new State("state1");
//out 为外部传给享元的 外部状态
public void operation(String out) {
//使用外部状态和内部状态来执行 operation操作
System.out.println("ConFlyweight1: " + out + state.getValue());
}
}
// 充数的
class ConFlyweight2 implements Flyweight {
private State state = new State("state2");
public void operation(String out) {
System.out.println("ConFlyweight2: " + state.getValue() + out );
}
}
class FlyweightFactory {
Map flyweights = new HashMap();
public Flyweight getFlyweight(String key) {
if (flyweights.containsKey(key)) {
return (Flyweight) flyweights.get(key);
} else {
// 这里就随便写的
Flyweight flyweight = null;
if (key.charAt(key.length() - 1) == '1') {
flyweight = new ConFlyweight1();
flyweights.put(key, flyweight);
} else {
flyweight = new ConFlyweight2();
flyweights.put(key, flyweight);
}
return flyweight;
}
}
}
public class FlyweightPattern {
public static void main(String[] args) {
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1a = factory.getFlyweight("flytest1");
flyweight1a.operation("outparam1");
}
}
***********************************************************************
// Bridge 模式例子
//对一处的操作 改成引用一个对象 具体操作再另一个对象中进行 这样便于功能扩展
package pattern.b.bridge;
interface Implementor {
void realOperation();
}
class ConImplementor1 implements Implementor {
public void realOperation() {
System.out.println("do the real operation1");
}
}
class ConImplementor2 implements Implementor {
public void realOperation() {
System.out.println("do the real operation2");
}
}
abstract class Abstraction {
protected Implementor imp;
public Abstraction(Implementor imp) {
this.imp = imp;
}
protected void med0() {}
abstract public void operation();
}
class ConAbstraction extends Abstraction{
public ConAbstraction(Implementor imp) {
super(imp);
}
public void operation() {
med0();
imp.realOperation();
}
}
public class BridgePattern {
public static void main(String[] args) {
Implementor imp = new ConImplementor1();
Abstraction abs = new ConAbstraction(imp);
abs.operation();
}
}
***********************************************************************
//Decorator 模式例子
package pattern.b.decorator;
//源部件和修饰类的共同接口
interface Component {
void operation();
}
class ConComponent implements Component {
public void operation() {
System.out.println("the begin operation");
}
}
//没有提供给component赋值的方法 所以声明这个类为抽象的 这里并没有抽象的方法就是不像让这个类有实例
abstract class Decotor implements Component{
private Component component;
public void operation() {
component.operation();
}
}
class ConDecotor1 extends Decotor {
private Component component;
public ConDecotor1(Component component) {
this.component = component;
}
public void operation() {
super.operation();
//!!注意这里 这里提供了功能的添加
// 这里就是Decorator的核心部分 不是修改功能而是添加功能 将一个component传入装饰类调用对象的接口
//方法 在此过程添加功能 重新实现接口方法的功能
med0();
}
private void med0() {
System.out.println("1");
}
}
class ConDecotor2 extends Decotor {
private Component component;
public ConDecotor2(Component component) {
this.component = component;
}
public void operation() {
super.operation();
med0();
}
private void med0() {
System.out.println("2");
}
}
//class
public class DecoratorPattern {
public static void main(String[] args) {
//注意 起点位置是从一个ConComponent开始的!!
Component component = new ConDecotor2(new ConDecotor1(new ConComponent()));
component.operation();
}
}
***********************************************************************
//Facade 的例子
//在子系统上建立了一层 对外使用感觉比较简单 Facade的方法中封装与子系统交互的逻辑
package pattern.b.facade;
class Exa1 {
public void med0() {}
}
class Exa2 {
public void themed() {}
}
//这就是一个简单的Facade的方法的例子
class Facade {
public void facdeMed() {
Exa1 exa1 = new Exa1();
exa1.med0();
Exa2 exa2 = new Exa2();
exa2.themed();
}
}
public class FacadePattern {
public static void main(String[] args) {
}
}
***********************************************************************
////////////////////////////////////////////////////////////////////
行为模式
////////////////////////////////////////////////////////////////////
//Command 模式例子
//感觉将一个类的方法 分散开了 抽象成了接口方法 注意 参数和返回值要一致
//每个Command封装一个命令 也就是一种操作
package pattern.c.command;
//这个是逻辑真正实现的位置
class Receiver {
public void med1() {}
public void med2() {}
}
interface Command {
// 要抽象成统一接口方法 是有局限性的
void execute();
}
class ConCommand1 implements Command{
private Receiver receiver;
public ConCommand1(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.med1();
}
}
class ConCommand2 implements Command{
private Receiver receiver;
public ConCommand2(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.med2();
}
}
class Invoker {
private Command command;
public Invoker(Command command) {
this.command = command;
}
public void action() {
command.execute();
}
}
public class CommandPattern {
public static void main(String[] args) {
Receiver receiver = new Receiver();
// 生成一个命令
Command command = new ConCommand1(receiver);
Invoker invoker = new Invoker(command);
invoker.action();
}
}
***********************************************************************
//Strategy 模式例子
//Strategy中封装了算法
package pattern.c.strategy;
interface Strategy {
void stMed();
}
class Constrategy1 implements Strategy {
public void stMed() {}
}
class constrategy2 implements Strategy {
public void stMed() {}
}
class Context {
private Strategy strategy;
public Context (Strategy strategy) {
this.strategy = strategy;
}
public void ContextInterface() {
strategy.stMed();
}
}
public class StrategyPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//State模式例子
//将一种状态和状态的助理封装倒state中
package pattern.c.state;
class Context {
private State state = new CloseState();
public void changeState(State state) {
this.state = state;
}
public void ruquest() {
state.handle(this);
}
}
interface State {
void handle(Context context);
}
//表示打开状态
class OpenState implements State{
public void handle(Context context) {
System.out.println("do something for open");
context.changeState(new CloseState());
}
}
//表示关闭状态
class CloseState implements State{
public void handle(Context context) {
System.out.println("do something for open");
context.changeState(new OpenState());
}
}
public class StatePattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Visitor模式例子
//双向传入
package pattern.c.visitor;
import java.util.*;
interface Visitor {
void visitConElementA(ConElementA conElementA);
void visitConElementB(ConElementB conElementB);
}
class ConVisitor1 implements Visitor{
public void visitConElementA(ConElementA conElementA) {
String value = conElementA.value;
conElementA.operation();
//do something
}
public void visitConElementB(ConElementB conElementB) {
String value = conElementB.value;
conElementB.operation();
//do something
}
}
class ConVisitor2 implements Visitor{
public void visitConElementA(ConElementA conElementA) {
String value = conElementA.value;
conElementA.operation();
//do something
}
public void visitConElementB(ConElementB conElementB) {
String value = conElementB.value;
conElementB.operation();
//do something
}
}
interface Element {
void accept(Visitor visitor);
}
class ConElementA implements Element {
String value = "aa";
public void operation() {}
public void accept(Visitor visitor) {
visitor.visitConElementA(this);
}
}
class ConElementB implements Element {
String value = "bb";
public void operation() {}
public void accept(Visitor visitor) {
visitor.visitConElementB(this);
}
}
class ObjectStructure {
private List Elements = new ArrayList();
public void action(Visitor visitor) {
Iterator it = Elements.iterator();
Element element = null;
while (it.hasNext()) {
element = (Element) it.next();
element.accept(visitor);
}
}
public void add(Element element) {
Elements.add(element);
}
}
public class VisitorPattern {
public static void main(String[] args) {
ObjectStructure objs = new ObjectStructure();
objs.add(new ConElementA());
objs.add(new ConElementA());
objs.add(new ConElementB());
objs.action(new ConVisitor1());
}
}
***********************************************************************
//Observer模式例子
package pattern.c.observable;
import java.util.*;
class State {}
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void myNotify();
State getState();
void setState(State state);
}
class ConSubject implements Subject {
List observers = new ArrayList();
State state = new State();
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void myNotify() {
Iterator it = observers.iterator();
Observer observer = null;
while (it.hasNext()) {
observer = (Observer) it.next();
observer.update();
}
}
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
}
}
interface Observer {
void update();
}
class ConObserver1 implements Observer{
private Subject subject;
public ConObserver1(Subject subject) {
this.subject = subject;
}
public void update() {
State state = subject.getState();
// do something with state
}
}
class ConObserver2 implements Observer{
private Subject subject;
public ConObserver2(Subject subject) {
this.subject = subject;
}
public void update() {
State state = subject.getState();
// do something with state
}
}
public class ObservablePattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Mediator模式例子
package pattern.c.mediator;
public interface Colleague {
void setState(String state);
String getState();
void change();
void action();
}
package pattern.c.mediator;
public class ConColleague1 implements Colleague {
private String state = null;
private Mediator mediator;
public void change() {
mediator.changeCol1();
}
public ConColleague1 (Mediator mediator) {
this.mediator = mediator;
}
public void setState(String state) {
this.state = state;
}
public String getState() {
return state;
}
public void action() {
System.out.println("this 2 and the state is " + state);
}
}
package pattern.c.mediator;
public class ConColleague2 implements Colleague {
private String state = null;
private Mediator mediator;
public ConColleague2 (Mediator mediator) {
this.mediator = mediator;
}
public void change() {
mediator.changeCol2();
}
public void setState(String state) {
this.state = state;
}
public String getState() {
return state;
}
public void action() {
System.out.println("this 1 and the state is " + state);
}
}
package pattern.c.mediator;
public class ConMediator implements Mediator {
private ConColleague1 con1;
private ConColleague2 con2;
public void setCon1(ConColleague1 con1) {
this.con1 = con1;
}
public void setCon2(ConColleague2 con2) {
this.con2 = con2;
}
public void changeCol1() {
String state = con1.getState();
con2.setState(state);
con2.action();
}
public void changeCol2() {
String state = con2.getState();
con1.setState(state);
con1.action();
}
}
package pattern.c.mediator;
public interface Mediator {
void setCon1(ConColleague1 con1);
void setCon2(ConColleague2 con2);
void changeCol1();
void changeCol2();
}
package pattern.c.mediator;
public class MediatorTest {
public static void main(String[] args) {
Mediator mediator = new ConMediator();
ConColleague1 col1 = new ConColleague1(mediator);
col1.setState("lq test in the MediatorTest main 18");
ConColleague2 col2 = new ConColleague2(mediator);
mediator.setCon1(col1);
mediator.setCon2(col2);
col1.change();
}
}
***********************************************************************
//Iterator模式例子
package pattern.c.iterator;
interface Aggregate {
MyIterator Iterator();
}
class ConAggregate {
public MyIterator Iterator() {
return new ConMyIterator();
}
}
interface MyIterator {
Object First();
Object Last();
boolean hasNext();
Object Next();
}
class ConMyIterator implements MyIterator{
Object[] objs = new Object[100];
int index = 0;
public Object First() {
index = 0;
return objs[index];
}
public Object Last() {
index = objs.length - 1;
return objs[index];
}
public boolean hasNext() {
return index < objs.length;
}
public Object Next() {
if (index == objs.length - 1) {
return null;
} else {
return objs[++index];
}
}
}
public class IteratorPattern {
public static void main(String[] args) {
}
}
***********************************************************************
// Template Method 模式例子
package pattern.c.template_method;
abstract class father {
abstract void med0();
abstract void med1();
//operation为一个模板方法
public void operation() {
med0();
med1();
// and other logic
}
}
class child extends father {
public void med0() {
System.out.println("the med0 method");
}
public void med1() {
System.out.println("the med1 method");
}
}
public class TemplateMethodPattern {
public static void main(String[] args) {
}
}
***********************************************************************
//Chain of Responsiblity模式例子
//将请求在链上传递
//如果是当前节点的请求就结束传递处理请求否则向下传递请求
//每个节点有另一个节点的引用 实现链状结构
package pattern.c.chain_of_responsiblity;
interface Handler{
void handleRequest(int key);
}
class ConHandler1 implements Handler {
private Handler handler;
public ConHandler1(Handler handler) {
this.handler = handler;
}
public void handleRequest(int key) {
if (key == 1) {
System.out.println("handle in 1");
//handle something
} else {
handler.handleRequest(key);
}
}
}
class ConHandler2 implements Handler {
private Handler handler;
public ConHandler2(Handler handler) {
this.handler = handler;
}
public void handleRequest(int key) {
if (key == 2) {
System.out.println("handle in 2");
//handle something
} else {
handler.handleRequest(key);
}
}
}
class ConHandler3 implements Handler {
private Handler handler;
public ConHandler3(Handler handler) {
this.handler = handler;
}
public void handleRequest(int key) {
if (key == 3) {
System.out.println("handle in 3");
//handle something
} else {
handler.handleRequest(key);
}
}
}
public class ChainOfResponsiblityPattern {
public static void main(String[] args) {
Handler handler = new ConHandler2(new ConHandler1(new ConHandler3(null)));
handler.handleRequest(3);
}
}
***********************************************************************
//Interpreter模式例子
/*
* Variable 表示变量 存储在上下文中
* Constant 终结表达式
* And 与的关系 双目
* Not 反的关系 单目
*/
package pattern.c.interpreter;
import java.util.*;
class Context {
private Map variables = new HashMap();
public boolean lookUp(Variable name) {
Boolean value = (Boolean) variables.get(name);
if (value == null) {
return false;
}
return value.booleanValue();
}
public void bind(Variable name, boolean value) {
variables.put(name, new Boolean(value));
}
}
interface Expression {
boolean interpret(Context cont);
}
class Constant implements Expression {
private boolean value;
public Constant(boolean value) {
this.value = value;
}
public boolean interpret(Context cont) {
return value;
}
}
class Variable implements Expression{
private String name;
public Variable(String name) {
this.name = name;
}
public boolean interpret(Context cont) {
return cont.lookUp(this);
}
}
class And implements Expression {
private Expression left;
private Expression right;
public And(Expression left, Expression right) {
this.left = left;
this.right = right;
}
public boolean interpret(Context cont) {
return left.interpret(cont) && right.interpret(cont);
}
}
class Not implements Expression {
private Expression expression;
public Not(Expression expression) {
this.expression = expression;
}
public boolean interpret(Context cont) {
return ! expression.interpret(cont);
}
}
public class InterpreterPattern {
public static void main(String[] args) {
Context cont = new Context();
Variable variable = new Variable("parameter1");
cont.bind(variable, true);
Expression and = new And(new Not(new Constant(true)), new And(new Constant(false), new Variable("parameter1")));
// (!(true)) && ((false)&&(true))
and.interpret(cont);
}
}
***********************************************************************
//Memento模式例子
package pattern.c.memento;
class Memento {
String value1;
int value2;
public Memento(String value1, int value2) {
this.value1 = value1;
this.value2 = value2;
}
}
class Originator {
private String value1;
private int value2;
public Originator(String value1, int value2) {
this.value1 = value1;
this.value2 = value2;
}
public void setMemento(Memento memento) {
value1 = memento.value1;
value2 = memento.value2;
}
public Memento createMemento() {
Memento memento = new Memento(value1, value2);
return memento;
}
public void setValue1(String value1) {
this.value1 = value1;
}
public void setValue2(int value2) {
this.value2 = value2;
}
}
class CareTaker {
private Memento memento;
public Memento retrieveMemento() {
return memento;
}
public void saveMemento(Memento memento) {
this.memento = memento;
}
}
public class MementoPattern {
public static void main(String[] args) {
Originator originator = new Originator("test1", 1);
CareTaker careTaker = new CareTaker();
//保存状态
careTaker.saveMemento(originator.createMemento());
originator.setValue1("test2");
originator.setValue2(2);
//恢复状态
originator.setMemento(careTaker.retrieveMemento());
}
}
***********************************************************************