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{

@Override
public void abstractMethod1() {
System.out.println("我实现了方法一");
}

@Override
public void abstractMethod2() {
// TODO Auto-generated method stub
//这里我不实现
}

}

class AbstractMethod2Template extends AbstractTemplate{

@Override
public void abstractMethod1() {
// TODO Auto-generated method stub
//这里我不实现
}

@Override
public void abstractMethod2() {
// TODO Auto-generated method stub
System.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();
// 默认日期不分隔，如：20120606
private 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和从网上查找到的学习资料，装载请注明出处。