本文转自：

 

创建模式

 

//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());

    }

}

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