[转]设计模式的例子

本文转自：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());
    }
}

***********************************************************************

posted on 2012-06-07 11:25 freeliver54 阅读(384) 评论(1) 编辑收藏举报

刷新页面返回顶部

Love in coding...

[转]设计模式的例子

导航

公告