【网摘】Java设计模式

原文地址：
http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

设计模式六大原则：
1.开闭原则：对扩展开放，对修改关闭。在程序需要进行扩展的时候，不能去修改原有的代码。
2.里氏代换原则：任何基类可以出现的地方，子类一定可以出现。
3.依赖倒转原则：针对接口编程，依赖于抽象而不依赖于具体。
4.接口隔离原则：使用多个隔离的接口，比使用单个接口好。
5.迪米特法则：也叫最少知道原则，即一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6.合成复用原则：尽量使用合成/聚合的方式，而不是使用继承。
设计模式分类：
创建型模式：
工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式：
适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式
行为型模式：
策略模式，模版方法模式，观察这么是，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
其他：并发型模式，线程池模式。

一、工厂方法模式
1.普通工厂模式

public interface Sender{
 public void Send();
}

public class MailSender implements Sender{
 @Override
 public void Send(){
  System.out.println("This is a mail sender!");
 }
} 

public class SmsSender implements Sender{
 @Override
 public void Send(){
  System.out.println("This is a sms sender!");
 }
}

public class SendFactory{
 public Sender produce(String type){
  if("mail".equals(type)){
   return new MailSender();
  }else if("sms".equals(type)){
   return new SmsSender();
  }else{
   System.out.println("请输入正确的类型！");
   return null;
  }
 }
}

public class FactoryTest{
 public static void main(String[] args){
  SendFacotry factory=new SendFactory();
  Sender sender=factory.produce("sms");
  sender.Send();
 }
}

2.多个工厂方法模式

对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象：

3.静态工厂方法模式

将上面的多个工厂方法模式里的方法置为静态，不需要创建实例，直接调用即可。

凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。

-------------------------------------------------------------------

二、抽象工厂模式

工厂方法模式有一个问题，就是类的创建依赖工厂类，如果想要扩展程序，必须对工厂类进行修改。抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

public interface Sender{
 public void Send();
}

public class MailSender implements Sender{
 @Override
 public void Send(){
  System.out.println("This is mail sender!");
 }
}

public class SmsSender implements Sender{
 @Override
 public void Send(){
  System.out.println("This is sms sender!");
 }
}

public interface Provider{
 public Sender produce();
}

public class SendMailFactory implements Provider{
 @Override
 public Sender produce(){
  return new MailSender();
 }
}

public class SendSmsFactory implements Provider{
 @Override
 public Sender produce(){
  return new SmsSender();
 }
}

public class Test{
 public static void main(String[] args){
  Provider provider=new SendMailFactory();
  Sender sender = provider.produce();
  sender.Send();
 }
}

--------------------------------------------------------------

三、单例模式 ？

在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

1. 某些类创建比较频繁，对于一些大型的对象，这是一笔很大的开销。

2. 省去了new操作符，降低了系统内存的使用率，减轻GC压力

3. 有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了，好比一个军队不能出现多个司令指挥。

初步实现：

public class Singleton{
 /*持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载*/
 private static Singleton instance=null;
 /*私有构造方法，防止被实例化*/
 private Singleton(){}
 /*静态工程方法，创建实例*/
 public static Singleton getInstance(){
  if(instance==null){
   instance=new Singleton();
  }
  return instance;
 }
 /*如果该对象被用于序列化，可以保证对象在序列化前后保持一致*/
 public Object readResolve(){
  return instance;
 }
}
/*
*
*/

---------------------------------------------------------------------------------------

四、建造者模式

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

public class Builder{
 private List<Sender> list = new ArrayList<Sender>();
 public void produceMailSender(int count){
  for(int i=0;i<count;i++){
   list.add(new MailSender());
  }
 }
 public void produceSmsSender(int count){
  for(int i=0;i<count;i++){
   list.add(new SmsSender());
  }
 }
}
public class Test{
 public static void main(String[] args){
  Builder builder=new Builder();
  builder.produceMailSender(10);
 }
}

-------------------------------------------------------------------

五、原型模式

该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深复制：将一个对象复制后，不论是基本数据类型还是引用类型，都是重新创建的。

public class Prototype implements Cloneable,Serializable{
 private static final long serialVersionUID=1L;
 private String string;
 private SerializableObject obj;
 /*浅复制*/
 public Object clone() throws CloneNotSupportedException{
  Prototype proto=(Prototype)super.clone();
  return proto;
 }
 /*深复制*/
 public Object deepClone() throws IOException, ClassNotFoundException{
  /*写入当前对象的二进制流*/
  ByteArrayOutputStream bos=new ByteArrayOutputStream();
  ObjectOutputStream oos=new ObjectOutputStream(bos);
  oos.writeObject(this);
  /*读出二进制流产生的新对象*/
  ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
  ObjectInputStream ois=new ObjectInputStream(bis);
  return ois.readObject();
 }
 public String getString(){
  return string;
 }
 public void setString(String string){
  this.string=string;
 }
 public SerializableObject getObj(){
  return obj;
 }
 public void setObj(SerializableObject obj){
  this.obj=obj;
 }
}
class SerializableObject implements Serializable{
 private static final long serialVersionUID=1L;
}

---------------------------------------------------------------

六、适配器模式 ？

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

1. 类的适配器模式

public class Source{
 public void method1(){
  System.out.println("this is original method!");
 }
}
public interface Targetable{
 /*与原类中的方法相同*/
 public void method1();
 /*新类的方法*/
 public void method2();
}
public class Adapter extends Source implements Targetable{
 @Override
 public void method2(){
  System.out.println("this is the targetable method!");
 }
}
public class AdapterTest{
 public static void main(String[] args){
  Targetable target=new Adapter();
  target.method1();
  target.method2();
 }
}

2.对象的适配器模式

修改Adapter类：

public class Wrapper implements Targetable{
 private Source source;
 public Wrapper(Source source){
  super();
  this.source=source;
 }
 @Override
 public void method2(){
  System.out.println("this is the target method!");
 }
 @Override
 public void method1(){
  source.method1();
 }
}
public class AdapterTest{
 public static void main(String[] args){
  Source source=new Source();
  Targetable target=new Wrapper(source);
  target.method1();
  target.method2();
 }
}

3. 接口的适配器模式

public interface Sourceable{
 public void method1();
 public void method2();
}
public abstract class Wrapper2 implements Sourceable{
 public void method1(){}
 public void method2(){}
}
public class SourceSub1 extends Wrapper2{
 public void method1(){
  System.out.println("the sourceable interface‘s first Sub1!");
 }
}
public class SourceSub2 extends Wrapper2{
 public void method2(){
  System.out.println("the sourceable interface‘s second Sub2!");
 }
}
public class WrappterTest{
 public static void main(String[] args){
  Sourceable source1=new SourceSub1();
  Sourceable source2=new SourceSub2();
  source1.method1();
  source1.method2();
  source2.method1();
  source2.method2();
 }
}

三种适配器模式的应用场景：

类适配器：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

对象适配器：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

接口适配器：当不希望实现一个接口中的所有方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

------------------------------------------------------------------------------------------------------

七、装饰模式

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

public interface Sourceable{
 public void method();
}
public class Source implements Sourceable{
 @Override
 public void method(){
  System.out.println("the original method!");
 }
}
public class Decorator implements Sourceable{
 private Sourceable source;
 public Decorator(Sourceable source){
  super();
  this.source=source;
 }
 @Override
 public void method(){
  System.out.println("before decorator!");
  source.method();
  System.out.println("after decorator!");
 }
}
public class DecoratorTest{
 public static void main(String[] args){
  Sourceable source=new Source();
  Sourceable obj=new Decorator(source);
  obj.method();
 }
}

应用场景：

1. 需要扩展一个类的功能。

2. 动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

缺点：产生过多相似的对象，不易排错。

------------------------------------------------------------------------

八、代理模式

代理模式就是多一个代理类出来，替原对象进行一些操作，与装饰者模式很像，但不同的是，代理模式直接在类中实例化出要操作的对象，进行间接使用。而装饰者模式是二者均存在，可以根据需求操作原对象，也可以操作装饰过的对象。

public interface Sourceable{
public void method();
}
public class Source implements Sourceable{
@Override
public void method(){
  System.out.println("the original method!");
}
}
public class Proxy implements Sourceable{
 private Source source;
 public Proxy(){
  super();
  this.source=new Source();
 }
 @Override
 public void method(){
  before();
  source.method();
  after();
 }
 private void before(){
  System.out.println("before proxy!");
 }
 private void after(){
  System.out.println("after proxy!");
 }
}
public class ProxyTest{
 public static void main(String[] args){
  Sourceable source=new Proxy();
  source.method();
 }
}

------------------------------------------------------------------------

九、外观模式

public class CPU{
 public void startup(){
  System.out.println("cpu startup!");
 }
 public void shutdown(){
  System.out.println("cpu shutdown!");
 }
}
public class Memory{
 public void startup(){
  System.out.println("memory startup!");
 }
 public void shutdown(){
  System.out.println("memory shutdown!");
 }
}
public class Disk{
 public void startup(){
  System.out.println("disk startup!");
 }
 public void shutdown(){
  System.out.println("disk shutdown!");
 }
}
public class Computer{
 private CPU cpu;
 private Memory memory;
 private Disk disk;
 public Computer(){
  cpu=new CPU();
  memory=new Memory();
  disk=new Disk();
 }
 public void startup(){
  System.out.println("start the computer!");
  cpu.startup();
  memory.startup();
  disk.startup();
  System.out.println("start computer finished!");
 }
 public void shutdown(){
  System.out.println("begin to close the computer!");
  cpu.shutdown();
  memory.shutdown();
  disk.shutdown();
  System.out.println("computer closed!");
 }
}
public class User{
 public static void main(String[] args){
  Computer computer=new Computer();
  computer.startup();
  computer.shutdown();
 }
}

-------------------------------------------------------------------------------------

十、桥接模式

把事物和具体实现分开，使他们各自独立的变化。例如JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码。

public interface Sourceable{
 public void method();
}
public class SourceSub1 implements Sourceable{
 @Override
 public void method(){
  System.out.println("This is the first sub!");
 }
}
public class SourceSub2 implements Sourceable{
 @Override
 public void method(){
  System.out.println("This is the second sub!");
 }
}
public abstract class Bridge{
 private Sourceable source;
 public void method(){
  source.method();
 }
 public Sourceable getSource(){
  return souce;
 }
 public void setSource(Sourceable source){
  this.source=source;
 }
}
public class MyBridge extends Bridge{
 public void method(){
  getSource().method();
 }
}
public class BridgeTest{
 public static void main(String[] args){
  Bridge bridge=new MyBridge();
  Sourceable source1=new SourceSub1();
  bridge.setSource(source1);
  bridge.method();
  Sourceable source2=new SourceSub2();
  bridge.setSource(source2);
  bridge.method();
 }
}

-------------------------------------------------------------------------------

十一、组合模式

又叫部分-整体模式，具体如下代码（不要当成真正的树数据结构）

public class TreeNode{
 private String name;
 private TreeNode parent;
 private Vector<TreeNode> children=new Vector<TreeNode>();
 public TreeNode(String name){
  this.name=name;
 }
 public String getName(){
  return name;
 }
 public void setName(String name){
  this.name=name;
 }
 public TreeNode getParent(){
  return parent;
 }
 public void setParent(TreeNode parent){
  this.parent=parent;
 }
 public void add(TreeNode node){
  children.add(node);
 }
 public void remove(Tree node){
  children.remove(node);
 }
 public Enumeration<TreeNode> getChildren(){
  return children.elements();
 }
}
public class Tree{
 TreeNode root=null;
 public Tree(String name){
  root=new TreeNode(name);
 }
 public static void main(String[] args){
  Tree tree=new Tree("A");
  TreeNode nodeB=new TreeNode("B");
  TreeNOde nodeC=new TreeNode("C");
  nodeB.add(nodeC);
  tree.root.add(nodeB);
  System.out.println("build the tree finished!");
 }
}

----------------------------------------------------------------------------------------------

十二、享元模式

----------------------------------------------------------------------------------------------

十三、策略模式

策略模式定义了一些列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。

public interface ICalculator{
 public int calculate(String exp);
}
public abstract class AbstractCalculator{
 public int[] split(String exp,String opt){
  String array[]=exp.split(opt);
  int arrayInt[]=new int[2];
  arrayInt[0]=Integer.parseInt(array[0]);
  arrayInt[1]=Integer.parseInt(array[1]);
  return arrayInt;
 }
}
public class Plus extends AbstractCalculator implements ICalculator{
 @Override
 public int calculate(String exp){
  int arrayInt[]=split(exp,"\\+");
  return arrayInt[0]+arrayInt[1];
 }
}
public class Minus extends AbstractCalculator implements ICalculator{
 @Override
 public int calculate(String exp){
  int arrayInt[]=split(exp,"-");
  return arrayInt[0]-arrayInt[1];
 }
}
public class Multiply extends AbstractCalculator implements ICalculator{
 @Override
 public int calculate(String exp){
  int arrayInt[]=split(exp,"\\*");
  return arrayInt[0]*arrayInt[1];
 }
}
public class StrategyTest{
 public static void main(String[] args){
  String exp="2+8";
  ICalculator cal=new Plus();
  int result=cal.calculate(exp);
  System.out.println(result);
 }
}

------------------------------------------------------------------------------------------

十四、模板方法模式

public abstract class AbstractCalculator{
 public final int calculate(String exp,String opt){
  int array[]=split(exp,opt);
  return calculate(array[0],array[1]);
 }
 abstract public int calculate(int num1,int num2);
 public int[] split(String exp,String opt){
  String array[]=exp.split(opt);
  int arrayInt[]=new int[2];
  arrayInt[0]=Integer.parseInt(array[0]);
  arrayInt[1]=Integer.parseInt(array[1]);
  return arrayInt;
 }
}
public class Plus extends AbstractCalculator{
 @Override
 public int calculate(int num1,int num2){
  return num1+num2;
 }
}
public class StrategyTest{
 public static void main(String[] args){
  String exp="8+8";
  AbstractCalculator cal=new Plus();
  int result=cal.calculate(exp,"\\+");
  System.out.println(result);
 }
}

-------------------------------------------------------------------------------------

十五、观察者模式

类似于邮件订阅和RSS订阅，当你订阅了该文章，如果后续有更新，会及时通知你。简而言之，当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化。如下图：

MySubject类是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。实现代码如下：

//Observer接口
public interface Observer{
 public void update();
}
//两个实现类
public class Observer1 implements Observer{
 @Override
 public void update(){
  System.out.println("ovserver 1 has received!");
 }
}
 public class Observer2 implements Observer{
 @Override
 public void update(){
  System.out.println("observer 2 has received!");
 }
}
//Subject接口及实现类：
public interface Subject{
 public void add(Observer observer);
 public void del(Observer observer);
 public void notifyObservers();
 public void operation();
}
public abstract class AbstractSubject implements Subject{
 private Vector<Observer> vector=new Vector<Observer>();
 @Override
 public void add(Observer observer){
  vector.add(observer);
 }
 @Override
 public void del(Observer observer){
  vector.remove(observer);
 }
 @Override
 public void notifyObservers(){
  Enumeration<Observer> enumo=vector.elements();
  while(enumo.hasMoreElements()){
   enumo.nextElement().update();
  }
 }
}
public class MySubject extends AbstractSubject{
 @Override
 public  void operation(){
  System.out.println("update self!");
  notifyObservers();
 }
}
//测试类
public class ObserverTest{
 public static void main(String[] args){
  Subject sub=new MySubject();
  sub.add(new Observer1());
  sub.add(new Observer2());
  sub.operation();
 }
}

--------------------------------------------------------------------------------

十六、迭代器模式

迭代器模式就是顺序访问聚集中的对象。

public interface Collection{
 public Iterator iterator();
 public Object get(int i);
 public int size();
}
public interface Iterator{
 public Object previous();
 public Object next();
 public boolean hasNext();
 public Object first();
}
public class MyCollection implements Collection{
 public String string[]={"A","B","C","D","E"};
 @Override
 public Iterator iterator(){
  return new MyIterator(this);
 }
 @Override
 public Object get(int i){
  return string[i];
 }
 @Override
 public int size(){
  return string.length;
 }
}
public class MyIterator implements Iterator{
 private Collection collection;
 private int pos=-1;
 public MyIterator(Collection collection){
  this.collection=collection;
 }
 @Override
 public Object previous(){
  if(pos>0){
   pos--;
  }
  return collection.get(pos);
 }
 @Override
 public Object next(){
  if(pos<collection.size()-1){
   pos++;
  }
  return collection.get(pos);
 }
 @Override
 public boolean hasNext(){
  if(pos<collection.size()-1){
   return true;
  }else{
   return false;
  }
 }
 @Override
 public Object first(){
  pos=0;
  return collection.get(pos);
 }
}
public class Test{
 public static void main(String[] args){
  Collection collection=new MyCollection();
  Iterator it=collection.iterator();
  while(it.hasNext()){
   System.out.println(it.next());
  }
 }
}

-----------------------------------------------------------------------------------------

十七、责任链模式

public interface Handler{
 public void operator();
}
public abstract class AbstractHandler{
 private Handler handler;
 public Handler getHandler(){
  return handler;
 }
 public void setHandler(Handler handler){
  this.handler=handler;
 }
}
public class MyHandler extends Abstracthandler implements Handler{
 private String name;
 public MyHandler(String name){
  this.name=name;
 }
 @Override
 public void operator(){
  System.out.println(name+"deal!");
  if(getHandler()!=null){
   getHandler().operator();
  }
 }
}
public class Test{
 public static void main(String[] args){
  MyHandler h1=new MyHandler("h1");
  MyHandler h2=new MyHandler("h2");
  MyHandler h3=new MyHandler("h3");
  h1.setHandler(h2);
  h2.setHandler(h3);
  h1.operator();
 }
}

------------------------------------------------------------------------------------

十八、命令模式

命令模式类似于司令员下令让士兵去干事，司令只需要发出命令，口令经过传递到士兵，士兵去执行，三个过程互相解耦。

public interface Command{
 public void exec();
}
public class MyCommand implements Command{
 private Receiver receiver;
 public MyCommand(Receiver receiver){
  this.receiver=receiver;
 }
 @Override
 public void exec(){
  receiver.action();
 }
}
public class Receiver{
 public void action(){
  System.out.println("command received!");
 }
}
public class Invoker{
 private Command command;
 public Invoker(Command command){
  this.command=command;
 }
 public void action(){
  command.exec();
 }
}
public class Test{
 public static void main(String[] args){
  Receiver receiver=new Receiver();
  Command cmd=new MyCommand(receiver);
  Invoker invoker=new Invoker(cmd);
  invoker.action();
 }
}

-----------------------------------------------------------------------------------

十九、备忘录模式

主要目的是保存一个对象的某个状态，以便在适当的时候回复对象，也就是备份。

public class Original{
 private String value;
 public String getValue(){
  return value;
 }
 public void setValue(String value){
  this.value=value;
 }
 public Original(String value){
  this.value=value;
 }
 public Memento createMemento(){
  return new Memento(value);
 }
 public void restoreMemento(Memento memento){
  this.value=memento.getValue();
 }
}
public class Memento{
 private String value;
 public Memento(String value){
  this.value=value;
 }
 public String getValue(){
  return value;
 }
 public void setValue(String value){
  this.value=value;
 }
}
public class Storage{
 private Memento memento;
 public Storage(Memento memento){
  this.memento=memento;
 }
 public Memento getMemento(){
  return memento;
 }
 public void setMemento(Memento memento){
  this.memento=memento;
 }
}
public class Test{
 public static void main(String[] args){
  //创建原始类
  Original origi=new Original("egg‘);
  //创建备忘录
  Storage storage=new Storage(origi.createMemento());
  //修改原始类的状态
  System.out.println("初始化状态为："+origi.getValue());
  origi.setValue("niu");
  System.out.println("修改后的状态为："+rigi.getValue());
  //回复原始类的状态
  origi.restoreMemento(storage.getMemento());
  System.out.println("恢复后的状态为："+origi.getValue());
 }
}

------------------------------------------------------------------------------------------

二十、状态模式

当对象的状态改变时，同时改变其行为

public class State{
 private String value;
 public String getValue(){
  return value;
 }
 public void setValue(String value){
  this.value=value;
 }
 public void method1(){
  System.out.println("execute the first opt!");
 }
 public void method2(){
  System.out.println("execute the second opt!");
 }
}
public class Context{
 private State state;
 public Context(State state){
  this.state=state;
 }
 public State getState(){
  return state;
 }
 public void setState(State state){
  this.state=state;
 }
 public void method(){
  if(state.getValue().equals("state1")){
   state.method1();
  }else if(state.getValue().equals("state2")){
   state.method2();
  }
 }
}
public class Test{
 public static void main(String[] args){
  State state=new State();
  Context context=new Context(state);
  //设置第一种状态
  state.setValue("state1");
  context.method();
  //设置第二种状态
  state.setValue("state2");
  context.method();
 }
}

也就是设置一个状态类，声明状态值以及各种状态下的方法，再将此类应用到其他类中。（不过更好的方法大概应该是把状态值和方法分开吧？）

-------------------------------------------------------------------------------------------------

二十一、访问者模式？？

下面这段代码看起来很普通，就是写了两个接口及两个接口实现类然后调用一下，不造跟这个访问者模式有什么关系

public interface Visitor{
 public void visit(Subject sub);
}
public class MyVisitor implements Visitor{
 @Override
 public void visit(Subject sub){
  System.out.println("visit the subject: "+sub.getSubject());
 }
}
public interface Subject{
 public void accept(Visitor visitor);
 public String getSubject();
}
public class MySubject implements Subject{
 @Override
 public void accept(Visitor visitor){
  visitor.visit(this);
 }
 @Override
 public String getSubject(){
  return "love";
 }
}
public class Test{
 public static void main(String[] args){
  Visitor visitor=new MyVisitor();
  Subject sub=new MySubject();
  sub.accept(visitor);
 }
}

--------------------------------------------------------------------------------------

二十二、中介者模式？？？

public interface Mediator{
 public void createMediator();
 public void workAll();
}
public class MyMediator implements Mediator{
 private User user1;
 private User user2;
 public User getUser1(){
  return user1;
 }
 public User getUser2(){
  return user2;
 }
 @Override
 public void createMediator(){
  user1=new User1(this);
  user2=new User2(this);
 }
 @Override
 public void workAll(){
  user1.work();
  user2.work();
 }
}
public abstract class User{
 private Mediator mediator;
 public Mediator getMediator(){
  return mediator;
 }
 public User(Mediator mediator){
  this.mediator=mediator;
 }
 public abstract void work();
}
public class User1 extends User{
 public User1(Mediator mediator){
  super(mediator);
 }
 @Override
 public void work(){
  System.out.println("user1 exe!");
 }
}
public class User2 extends User{
 public User2(Mediator mediator){
  super(mediator);
 }
 @Override
 public void work(){
  System.out.println("user2 exe!");
 }
}
public class Test{
 public static void main(String[] args){
  Mediator mediator=new MyMediator();
  mediator.createMediator();
  mediator.workAll();
 }
}

--------------------------------------------------------------------------------------------

二十三、解释器模式？？？

public interface Expression{
 public int interpret(Context context);
}
public class Plus implements Expression{
 @Override
 public int interpret(Context context){
  return context.getNum1()+context.getNum2();
 }
}
public class Minus implements Expression{
 @Override
 public int interpret(Context context){
  return context.getNum1()-context.getNum2();
 }
}
public class Context{
 private int num1;
 private int num2;
 public Context(int num1,int num2){
  this.num1=num1;
  this.num2=num2;
 }
 public int getNum1(){
  return num1;
 }
 public void setNum1(int num1){
  this.num1=num1;
 }
 public getNum2(){
  return num2;
 }
public class Test{
 public static void main(String[] args){
  //计算9+8-2
  int result=new Minus().interpret((new Context(new Plus().interpret(new Context(9,2)),8)));
  System.out.println(result);
 }
}