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 components = new ArrayList();
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;
}
} interface Component2 {
public void operation();
}
class Composite2 implements Component2 {
private List components = new ArrayList();
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和从网上查找到的学习资料，装载请注明出处。