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