java设计模式（三）——模板、访问者、组合、解释器、迭代器、中介者

一、TemplateMethod模板方法模式

模板方法模式是类的行为模式。准备一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，
然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，
从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。

public class TemplateMethodPattern {public static void main(String[] args) {AbstractTemplate template = new AbstractMethod1Template();template.templateMethod();AbstractTemplate template2 = new AbstractMethod2Template();template2.templateMethod();}}abstract class AbstractTemplate {    /**     * 模板方法     */    public void templateMethod(){        //调用基本方法        abstractMethod1();        abstractMethod2();        implementsMethod();    }    public abstract void abstractMethod1();    public abstract void abstractMethod2();    private final void implementsMethod(){        System.out.println("自己实现的方法");    }}class AbstractMethod1Template extends AbstractTemplate{@Overridepublic void abstractMethod1() {System.out.println("我实现了方法一");}@Overridepublic void abstractMethod2() {// TODO Auto-generated method stub//这里我不实现}}class AbstractMethod2Template extends AbstractTemplate{@Overridepublic void abstractMethod1() {// TODO Auto-generated method stub//这里我不实现}@Overridepublic void abstractMethod2() {// TODO Auto-generated method stubSystem.out.println("我实现了方法二");}}

输出结果：

我实现了方法一
自己实现的方法
我实现了方法二
自己实现的方法

二、Visitor访问者设计模式

Visitor访问者设计模式有以下两个特点：
(1).对元素的访问不是访问者主动发起的，而是通过元素接收访问者来访问自己。
(2).对元素的操作不是元素自己主动调用，而是通过访问者的访问方法来操作元素。
Visitor访问者设计模式的角色：
(1) 访问者角色（Visitor）：声明一个访问接口。接口的名称和方法的参数标识了向访问者发送请求的元素角色。
这样访问者就可以通过该元素角色的特定接口直接访问它。
(2) 具体访问者角色（Concrete Visitor）：实现访问者角色（Visitor）接口
(3)元素角色（Element）：定义一个Accept操作，它以一个访问者为参数。
(4) 具体元素角色（Concrete Element）：实现元素角色（Element）接口。
(5) 对象结构角色（Object Structure）：具体元素的集合，提供一个高层的接口允许访问者角色访问它的元素。

public class VisitorPattern {public static void main(String[] args) {IElement[] list = { new ElementA(), new ElementB(), new ElementC() };IVisitor visitor = new MyVisitor();for (int i = 0; i < list.length; i++) {list[i].accept(visitor);}}}//抽象访问者interface IVisitor {public void visit(ElementA element);public void visit(ElementB element);public void visit(ElementC element);}// 具体访问者class MyVisitor implements IVisitor {public void visit(ElementA element) {element.operationA();}public void visit(ElementB element) {element.operationB();}public void visit(ElementC element) {element.operationC();}}// 抽象元素interface IElement {public void accept(IVisitor visitor);}// 具体元素class ElementA implements IElement {public void accept(IVisitor visitor) {visitor.visit(this);}public void operationA() {System.out.println("ElementA do operationA()……");}}class ElementB implements IElement {public void accept(IVisitor visitor) {visitor.visit(this);}public void operationB() {System.out.println("ElementB do operationB()……");}}class ElementC implements IElement {public void accept(IVisitor visitor) {visitor.visit(this);}public void operationC() {System.out.println("ElementC do operationC()……");}}

输出结果：

ElementA  do operationA()……
ElementB do operationB()……
ElementC do operationC()……

三、Composite组合设计模式

Composite组合设计模式：又称部分－整体（Part－Whole）模式
组合设计模式将对象组织到树型结构中，可以用来描述整体与部分的关系。组合模式可以使客户端将单纯元素与复合元素同等看待。
1、透明式 ：作为第一种选择，在Compotent里面声明所有的用来管理子类对象的方法，包括add()、remove()、以及getChild()方法。
这样做的好处是所有的构件类都有相同的接口。在客户端看来，树叶类对象与合成类对象的区别起码在接口层次上消失了，
客户端 可以同等地对待所有的对象。这就是透明形式的合成模式。
这个选择的缺点是不够安全，因为树叶对象和组合类对象的在本质上是有区别的。
树叶类对象不可能有下一个层次的对象， 因此add() remove() getChild()方法没有意义，但是在编译时期不会出错，而只会在运行期出错。

interface Component {public void operation();public void add(Component component);public void remove(Component component);public Iterator iter();}class Composite implements Component {private List<Component> components = new ArrayList<Component>();public void operation() {Iterator iter = iter();while (iter.hasNext()) {((Component) iter.next()).operation();}}public void add(Component component) {components.add(component);}public void remove(Component component) {components.remove(component);}public Iterator iter() {return components.iterator();}}class Leaf implements Component {public void operation() {System.out.println("Leaf component operation");}public void add(Component component) {}public void remove(Component component) {}public Iterator iter() {return null;}}

2、是在Composite类里而声明所有的用来管理子类对象的方法。这样的做法是安全的做法。树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。 这个方式的缺点就是不够透明，因为树叶类和合成类将具有不同的接口。

interface Component2 {public void operation();}class Composite2 implements Component2 {private List<Component2> components = new ArrayList<Component2>();public void operation() {Iterator iter = iter();while (iter.hasNext()) {((Component2) iter.next()).operation();}}// 管理方法只存在于Composite中public void add(Component2 component) {components.add(component);}public void remove(Component2 component) {components.remove(component);}public Iterator iter() {return components.iterator();}}class Leaf2 implements Component2 {public void operation() {System.out.println("Leaf component operation");}}

四、Interpreter解释器设计模式

Interpreter解释器设计模式的定义：给定一个语言，定义其文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
Interpreter解释器设计模式角色如下：
(1).抽象表达式(AbstractExpression)角色：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要定义一个interpret()方法，称做解释操作。
(2).终结符表达式(TerminalExpression)角色：没有子节点的表达式。
(3).非终结符表达式(NonterminalExpression)角色：有子节点的表达式，解释操作以递归方式调用其子节点表达式。
(4).上下文(Context)角色：上下文提供解释器之外的一些全局信息，比如变量的真实量值等。

public class InterpreterPattern {public static void main(String[] args) {Date date = new Date();AbstractExpression expression1 = new DataFormatExpression();System.out.println(expression1.format(date));AbstractExpression expression2 = new DataFormatExpression("yyyy-MM-dd");System.out.println(expression2.format(date));AbstractExpression expression3 = new DataFormatExpression("yyyy/MM/dd");System.out.println(expression3.format(date));}}// 抽象表达式interface AbstractExpression {public String format(Date date);}// 具体的日期格式化表达式class DataFormatExpression implements AbstractExpression {private static final String pattern1 = "yyyy-MM-dd";private static final String pattern2 = "yyyy/MM/dd";private static final Calendar calendar = Calendar.getInstance();// 默认日期不分隔，如：20120606private String separator = "";public DataFormatExpression() {}public DataFormatExpression(String pattern) {if (pattern1.equals(pattern)) {separator = "-";} else if (pattern2.equals(pattern)) {separator = "/";}}public String getYear(Calendar cal) {return cal.get(Calendar.YEAR) + "";}public String getMonth(Calendar cal) {int month = cal.get(Calendar.MONTH) + 1;return month < 10 ? "0" + month : "" + month;}public String getDay(Calendar cal) {int day = cal.get(Calendar.DAY_OF_MONTH);return day < 10 ? "0" + day : "" + day;}public String format(Date date) {calendar.setTime(date);return getYear(calendar) + separator + getMonth(calendar) + separator+ getDay(calendar);}}

输出结果：

20131020
2013-10-20
2013/10/20

五、Iterator迭代器设计模式

public class IteratorPattern {    public static void main(String[] args){          Aggregate ag = new ConcreteAggregate();          ag.add("小明");          ag.add("小红");          ag.add("小刚");          Iterator it = ag.iterator();          while(it.hasNext()){              String str = (String)it.next();              System.out.println(str);          }      }  }//抽象容器：一般是一个接口，提供一个iterator()方法，还有其他常用的操作集合的方法，例如java中的Collection接口，List接口，Set接口等。interface Aggregate {    public void add(Object obj);    public void remove(Object obj);    public Iterator iterator();  }  //具体容器：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，//List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。class ConcreteAggregate implements Aggregate {    private List list = new ArrayList();    public void add(Object obj) {        list.add(obj);    }    public Iterator iterator() {        return new ConcreteIterator(list);    }    public void remove(Object obj) {        list.remove(obj);    }  }  //抽象迭代器:定义遍历元素所需要的方法，一般来说会有这么几个方法：取得第一个元素的方法first()，取得下一个元素的方法next()，//判断是否遍历结束的方法hasNext()，移出当前对象的方法remove(),interface Iterator {      public Object next();      public boolean hasNext();  }  //迭代器实现：实现迭代器接口中定义的方法，完成集合的迭代。class ConcreteIterator implements Iterator{      private List list = new ArrayList();      private int cursor =0;      public ConcreteIterator(List list){          this.list = list;      }      public boolean hasNext() {          if(cursor==list.size()){              return false;          }          return true;      }      public Object next() {          Object obj = null;          if(this.hasNext()){              obj = this.list.get(cursor++);          }          return obj;      }  }  

输出结果：

小明
小红
小刚

六、Mediator中介者设计模式

Mediator中介者设计模式是通过一个中介对象封装一系列关于对象交互行为.
Mediator中介者设计模式中的角色如下：
(1).中介者（Mediator）：抽象定义了“同事”（colleagues，稍后有定义）们通信的接口。
(2).具体中介者（Concrete Mediator）：实现了“同事”间的通信接口。
(3).同事（Colleague）：参与通信的实体抽象。
(4).具体同事（Concrete Colleague）：实现的参与通信的实体。

public class MediatorPattern {public static void main(String[] args) {// 创建中介Mediator mediator = new ConcreteMediator();// 创建同事，并为同事设置中介PersonA personA = new PersonA(mediator);PersonB personB = new PersonB(mediator);// 向中介设置同事((ConcreteMediator) mediator).setPersonA(personA);((ConcreteMediator) mediator).setPersonB(personB);// 开始聊天personA.send("Hi, B!");personB.send("Hello, A!");}}// 中介者interface Mediator {public void send(String msg, Person person);}// 具体中介者class ConcreteMediator implements Mediator {// 中介者所联系的交互对象private PersonA personA;private PersonB personB;public void setPersonA(PersonA personA) {this.personA = personA;}public void setPersonB(PersonB personB) {this.personB = personB;}public void send(String msg, Person person) {if (person.equals(personA)) {personA.greeting(msg);} else {personB.greeting(msg);}}}// 抽象同事abstract class Person {// 同事和中介者打交道public Mediator mediator;public Person(Mediator mediator) {this.mediator = mediator;}}// 具体同事class PersonA extends Person {public PersonA(Mediator mediator) {super(mediator);}public void send(String msg) {mediator.send(msg, this);}public void greeting(String msg) {System.out.println("PersonA: " + msg);}}class PersonB extends Person {public PersonB(Mediator mediator) {super(mediator);}public void send(String msg) {mediator.send(msg, this);}public void greeting(String msg) {System.out.println("PersonB: " + msg);}}

输出结果：

PersonA: Hi, B!
PersonB: Hello, A!

备注：java设计模式的学习主要是参考一位牛人http://blog.csdn.net/chjttony和从网上查找到的学习资料，装载请注明出处。