Java经典设计模式共有21中，分为三大类：建立型模式（5种）、结构型模式（7种）和行为型模式（11种）。java
本文主要讲行为型模式，建立型模式和结构型模式能够看博主的另外两篇文章：Java经典设计模式之五大建立型模式（附实例和详解）、 Java经典设计模式之七大结构型模式（附实例和详解）。算法
行为型模式细分为以下11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。设计模式
接下来对11种行为型模式逐个进行介绍。网络
1、策略模式
策略模式定义了一系列算法，并将每一个算法封装起来，使他们能够相互替换，且算法的变化不会影响到使用算法的客户。须要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（无关紧要，属于辅助类，视实际需求是否添加），提供辅助函数。数据结构
首先统一接口：框架
| 1dom 2ide 3函数 4测试 5 |
package com.model.behaviour;
public interface ICalculator {
public int calculate(String exp);
}
|
辅助类：
| 1 2 3 4 5 6 7 8 9 10 11 12 |
package com.model.behaviour;
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;
}
}
|
三个实现类：
| 1 2 3 4 5 6 7 8 9 10 |
package com.model.behaviour;
public class Plus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp, "\\+");
return arrayInt[0] + arrayInt[1];
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 |
package com.model.behaviour;
public class Minus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp, "\\-");
return arrayInt[0] - arrayInt[1];
}
}
|
| 1 2 3 4 5 6 7 8 9 10 |
package com.model.behaviour;
public class Multiply extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"\\*");
return arrayInt[0]*arrayInt[1];
}
}
|
测试类：
| 1 2 3 4 5 6 7 8 9 10 11 |
package com.model.behaviour;
public class StrategyTest {
public static void main(String[] args) {
String exp = "8-2";
ICalculator cal = new Minus();
int result = cal.calculate(exp);
System.out.println(exp + "=" + result);
}
}
|
策略模式的决定权在用户，系统自己提供不一样算法的实现，新增或者删除算法，对各类算法作封装。所以，策略模式多用在算法决策系统中，外部用户只须要决定用哪一个算法便可。
2、模板方法模式
解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1…n个方法，能够是抽象的，也能够是实际的方法，定义一个类，继承该抽象类，重写抽象方法，经过调用抽象类，实现对子类的调用。
就是在AbstractCalculator类中定义一个主方法calculate，calculate()调用spilt()等，Plus和Minus分别继承AbstractCalculator类，经过对AbstractCalculator的调用实现对子类的调用，看下面的例子：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package com.model.behaviour;
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;
}
}
|
| 1 2 3 4 5 6 7 8 9 |
package com.model.behaviour;
public class Plus extends AbstractCalculator {
@Override
public int calculate(int num1,int num2) {
return num1 + num2;
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 |
package com.model.behaviour;
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);
}
}
|
3、观察者模式
包括这个模式在内的接下来的四个模式，都是类和类之间的关系，不涉及到继承。
观察者模式很好理解，相似于邮件订阅和RSS订阅，当咱们浏览一些博客或wiki时，常常会看到RSS图标，就这的意思是，当你订阅了该文章，若是后续有更新，会及时通知你。其实，简单来说就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，而且随着变化！对象之间是一种一对多的关系。
| 1 2 3 4 5 |
package com.model.behaviour;
public interface Observer {
public void update();
}
|
| 1 2 3 4 5 6 7 8 9 |
package com.model.behaviour;
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received!");
}
}
|
| 1 2 3 4 5 6 7 8 9 10 |
package com.model.behaviour;
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package com.model.behaviour;
public interface Subject {
/*增长观察者*/
public void add(Observer observer);
/*删除观察者*/
public void del(Observer observer);
/*通知全部的观察者*/
public void notifyObservers();
/*自身的操做*/
public void operation();
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package com.model.behaviour;
import java.util.Enumeration;
import java.util.Vector;
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();
}
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 |
package com.model.behaviour;
public class MySubject extends AbstractSubject {
@Override
public void operation() {
System.out.println("update self!");
notifyObservers();
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
package com.model.behaviour;
public class ObserverTest {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
|
运行结果：
| 1 2 3 |
update self!
observer1 has received!
observer2 has received!
|
也许看完实例以后仍是比较抽象，再将文字描述和代码实例看一两遍吧，而后结合工做中看哪些场景可使用这种模式以加深理解。
4、迭代子模式
顾名思义，迭代器模式就是顺序访问汇集中的对象，通常来讲，集合中很是常见，若是对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是须要遍历的对象，即汇集对象，二是迭代器对象，用于对汇集对象进行遍历访问。
具体来看看代码实例：
| 1 2 3 4 5 6 7 8 9 10 11 12 |
package com.model.behaviour;
public interface Collection {
public Iterator iterator();
/* 取得集合元素 */
public Object get(int i);
/* 取得集合大小 */
public int size();
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package com.model.behaviour;
public interface Iterator {
// 前移
public Object previous();
// 后移
public Object next();
public boolean hasNext();
// 取得第一个元素
public Object first();
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package com.model.behaviour;
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;
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
package com.model.behaviour;
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);
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 |
package com.model.behaviour;
public class Test {
public static void main(String[] args) {
Collection collection = new MyCollection();
Iterator it = (Iterator) collection.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
|
输出结果：
此处咱们貌似模拟了一个集合类的过程，感受是否是很爽？其实JDK中各个类也都是这些基本的东西，加一些设计模式，再加一些优化放到一块儿的，只要咱们把这些东西学会了，掌握好了，咱们也能够写出本身的集合类，甚至框架！
5、责任链模式
责任链模式，有多个对象，每一个对象持有对下一个对象的引用，这样就会造成一条链，请求在这条链上传递，直到某一对象决定处理该请求。可是发出者并不清楚到底最终那个对象会处理该请求，因此，责任链模式能够实现，在隐瞒客户端的状况下，对系统进行动态的调整。
| 1 2 3 4 5 |
package com.model.behaviour;
public interface Handler {
public void operator();
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.model.behaviour;
public abstract class AbstractHandler {
private Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.model.behaviour;
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();
}
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.model.behaviour;
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();
}
}
|
运行结果：
| 1 2 3 |
h1deal!
h2deal!
h3deal!
|
此处强调一点就是，连接上的请求能够是一条链，能够是一个树，还能够是一个环，模式自己不约束这个，须要咱们本身去实现，同时，在一个时刻，命令只容许由一个对象传给另外一个对象，而不容许传给多个对象。
6、命令模式
命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的做用是，发出口令，口令通过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其余人，只须要作好本身的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。
| 1 2 3 4 5 |
package com.model.behaviour;
public interface Command {
public void exe();
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
package com.model.behaviour;
public class MyCommand implements Command {
private Receiver receiver;
public MyCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void exe() {
receiver.action();
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package com.model.behaviour;
public class Invoker {
private Command command;
public Invoker(Command command) {
this.command = command;
}
public void action() {
command.exe();
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 |
package com.model.behaviour;
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();
}
}
|
命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉Struts的同窗应该知道，Struts其实就是一种将请求和呈现分离的技术，其中必然涉及命令模式的思想！
7、备忘录模式
主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，我的以为叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各类属性，A能够决定须要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操做。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package com.model.behaviour;
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();
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.model.behaviour;
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;
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.model.behaviour;
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;
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package com.model.behaviour;
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("修改后的状态为：" + origi.getValue());
// 回复原始类的状态
origi.restoreMemento(storage.getMemento());
System.out.println("恢复后的状态为：" + origi.getValue());
}
}
|
输出结果：
| 1 2 3 |
初始化状态为：egg
修改后的状态为：niu
恢复后的状态为：egg
|
若是还不能理解，能够给Original类添加一个属性name，而后其余类进行相应的修改试试。
8、状态模式
核心思想就是：当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来讲，有几种状态，在线、隐身、忙碌等，每一个状态对应不一样的操做，并且你的好友也能看到你的状态，因此，状态模式就两点：一、能够经过改变状态来得到不一样的行为。二、你的好友能同时看到你的变化。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package com.model.behaviour;
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!");
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package com.model.behaviour;
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() {
System.out.println("状态为：" + state.getValue());
if (state.getValue().equals("state1")) {
state.method1();
} else if (state.getValue().equals("state2")) {
state.method2();
}
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.model.behaviour;
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();
}
}
|
运行结果：
| 1 2 3 4 |
状态为：state1
execute the first opt!
状态为：state2
execute the second opt!
|
根据这个特性，状态模式在平常开发中用的挺多的，尤为是作网站的时候，咱们有时但愿根据对象的某一属性，区别开他们的一些功能，好比说简单的权限控制等。
9、访问者模式
访问者模式把数据结构和做用于结构上的操做解耦合，使得操做集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。由于访问者模式使得算法操做增长变得容易。若系统数据结构对象易于变化，常常有新的数据对象增长进来，则不适合使用访问者模式。访问者模式的优势是增长操做很容易，由于增长操做意味着增长新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增长新的数据结构很困难。
访问者模式算是最复杂也是最难以理解的一种模式了。它表示一个做用于某对象结构中的各元素的操做。它使你能够在不改变各元素类的前提下定义做用于这些元素的新操做。
涉及角色：
1.Visitor 抽象访问者角色，为该对象结构中具体元素角色声明一个访问操做接口。该操做接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问者就能够经过该元素角色的特定接口直接访问它。
2.ConcreteVisitor.具体访问者角色，实现Visitor声明的接口。
3.Element 定义一个接受访问操做(accept())，它以一个访问者(Visitor)做为参数。
4.ConcreteElement 具体元素，实现了抽象元素(Element)所定义的接受操做接口。
5.ObjectStructure 结构对象角色，这是使用访问者模式必备的角色。它具有如下特性：能枚举它的元素；能够提供一个高层接口以容许访问者访问它的元素；若有须要，能够设计成一个复合对象或者一个汇集（如一个列表或无序集合）。
| 1 2 3 4 5 |
abstract class Element
{
public abstract void accept(IVisitor visitor);
public abstract void doSomething();
}
|
| 1 2 3 4 5 6 7 8 |
class ConcreteElement1 extends Element{
public void doSomething(){
System.out.println("这是元素1");
}
public void accept(IVisitor visitor){
visitor.visit(this);
}
}
|
| 1 2 3 4 5 6 7 8 |
class ConcreteElement2 extends Element{
public void doSomething(){
System.out.println("这是元素2");
}
public void accept(IVisitor visitor){
visitor.visit(this);
}
}
|
| 1 2 3 4 |
interface IVisitor{
public void visit(ConcreteElement1el1);
public void visit(ConcreteElement2el2);
}
|
| 1 2 3 4 5 6 7 8 |
class Visitor implements IVisitor{
public void visit(ConcreteElement1 el1){
el1.doSomething();
}
public void visit(ConcreteElement2 el2){
el2.doSomething();
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class ObjectStruture{
public static List<Element> getList(){
List<Element>list = new ArrayList<Element>();
Random ran = newRandom();
for(int i = 0 ; i < 10 ; i ++){
int a=ran.nextInt(100);
if(a>50){
list.add (newConcreteElement1());
}else{
list.add (newConcreteElement2());
}
}
return list;
}
}
|
| 1 2 3 4 5 6 7 8 |
public class Client{
public static void main (String[]args){
List<Element> list = ObjectStruture.getList();
for(Elemente:list){
e.accept(newVisitor());
}
}
}
|
10、中介者模式
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各对象不须要显式地相互引用，从而使其耦合松散，并且能够独立地改变它们之间的交互。
举例：在一个公司里面，有不少部门、员工（咱们统称他们互相为Colleague“同事”），为了完成必定的任务，“同事”之间确定有许多须要互相配合、交流的过程。若是由各个“同事”频繁地处处去与本身有关的“同事”沟通，这样确定会造成一个多对多的杂乱的联系网络而形成工做效率低下。
此时就须要一位专门的“中介者”给各个“同事”分配任务，以及统一跟进你们的进度并在“同事”之间实时地进行交互，保证“同事”之间必须的沟通交流。很明显咱们知道此时的“中介者”担任了沟通“同事”彼此之间的重要角色了，“中介者”使得每一个“同事”都变成一对一的联系方式，减轻了每一个“同事”的负担，加强工做效率。
同事类族：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.model.behaviour;
public abstract class AbstractColleague {
protected AbstractMediator mediator;
/**既然有中介者，那么每一个具体同事必然要与中介者有联系，
* 不然就不必存在于 这个系统当中，这里的构造函数至关
* 于向该系统中注册一个中介者，以取得联系
*/
public AbstractColleague(AbstractMediator mediator) {
this.mediator = mediator;
}
// 在抽象同事类中添加用于与中介者取得联系（即注册）的方法
public void setMediator(AbstractMediator mediator) {
this.mediator = mediator;
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//具体同事A
package com.model.behaviour;
public class ColleagueA extends AbstractColleague {
//每一个具体同事都经过父类构造函数与中介者取得联系
public ColleagueA(AbstractMediator mediator) {
super(mediator);
}
//每一个具体同事必然有本身份内的事，不必与外界相关联
public void self() {
System.out.println("同事A --> 作好本身份内的事情 ...");
}
//每一个具体同事总有须要与外界交互的操做，经过中介者来处理这些逻辑并安排工做
public void out() {
System.out.println("同事A --> 请求同事B作好份内工做 ...");
super.mediator.execute("ColleagueB", "self");
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
//具体同事B
package com.model.behaviour;
public class ColleagueB extends AbstractColleague {
public ColleagueB(AbstractMediator mediator) {
super(mediator);
}
public void self() {
System.out.println("同事B --> 作好本身份内的事情 ...");
}
public void out() {
System.out.println("同事B --> 请求同事A作好份内工做 ...");
super.mediator.execute("ColleagueA", "self");
}
}
|
中介者类族：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package com.model.behaviour;
public abstract class AbstractMediator {
//中介者确定须要保持有若干同事的联系方式
protected Hashtable<String, AbstractColleague> colleagues = new Hashtable<String, AbstractColleague>();
//中介者能够动态地与某个同事创建联系
public void addColleague(String name, AbstractColleague c) {
this.colleagues.put(name, c);
}
//中介者也能够动态地撤销与某个同事的联系
public void deleteColleague(String name) {
this.colleagues.remove(name);
}
//中介者必须具有在同事之间处理逻辑、分配任务、促进交流的操做
public abstract void execute(String name, String method);
}
|
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//具体中介者
package com.model.behaviour;
public class Mediator extends AbstractMediator{
//中介者最重要的功能，来回奔波与各个同事之间
public void execute(String name, String method) {
if("self".equals(method)){ //各自作好份内事
if("ColleagueA".equals(name)) {
ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
colleague.self();
}else {
ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
colleague.self();
}
}else { //与其余同事合做
if("ColleagueA".equals(name)) {
ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
colleague.out();
}else {
ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
colleague.out();
}
}
}
}
|
测试类：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//测试类
package com.model.behaviour;
public class Client {
public static void main(String[] args) {
//建立一个中介者
AbstractMediator mediator = new Mediator();
//建立两个同事
ColleagueA colleagueA = new ColleagueA(mediator);
ColleagueB colleagueB = new ColleagueB(mediator);
//中介者分别与每一个同事创建联系
mediator.addColleague("ColleagueA", colleagueA);
mediator.addColleague("ColleagueB", colleagueB);
//同事们开始工做
colleagueA.self();
colleagueA.out();
System.out.println("======================合做愉快，任务完成！\n");
colleagueB.self();
colleagueB.out();
System.out.println("======================合做愉快，任务完成！");
}
}
|
运行结果：
| 1 2 3 4 5 6 7 8 9 |
同事A --> 作好本身份内的事情 ...
同事A --> 请求同事B作好份内工做 ...
同事B --> 作好本身份内的事情 ...
======================合做愉快，任务完成！
同事B --> 作好本身份内的事情 ...
同事B --> 请求同事A作好份内工做 ...
同事A --> 作好本身份内的事情 ...
======================合做愉快，任务完成！
|
11、解释器模式
解释器模式：给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。
解释器模式是一个比较少用的模式。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package com.model.behaviour;
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 int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
}
|
| 1 2 3 4 5 |
package com.model.behaviour;
public interface Expression {
public int interpret(Context context);
}
|
| 1 2 3 4 5 6 7 8 9 |
package com.model.behaviour;
public class Minus implements Expression {
@Override
public int interpret(Context context) {
return context.getNum1()-context.getNum2();
}
}
|
| 1 2 3 4 5 6 7 8 9 |
package com.model.behaviour;
public class Plus implements Expression {
@Override
public int interpret(Context context) {
return context.getNum1()+context.getNum2();
}
}
|
| 1 2 3 4 5 6 7 8 9 10 11 |
package com.model.behaviour;
public class Test {
public static void main(String[] args) {
// 计算9+2-8的值
int result = new Minus().interpret((new Context(new Plus()
.interpret(new Context(9, 2)), 8)));
System.out.println(result);
}
}
|
注，本文参考了另一位博主的文章，某些地方有结合本身的一些理解加以修改：
http://blog.csdn.net/zhangerqing/article/details/8194653