對于開發人員來說，設計模式有時候就是一道坎，但是設計模式又非常有用，過了這道坎，它可以讓你水平提高一個檔次。而在android開發中，必要的了解一些設計模式又是必須的，因為設計模式在Android源碼中，可以說是無處不在。對于想系統的學習設計模式的同學，這里推薦一本書，《大話設計模式》。

Android常用設計模式系列：

面向對象的基礎特征
面向對象的設計原則
單例模式
模板模式
適配器模式
工廠模式
代理模式
原型模式
策略模式
Build模式
觀察者模式
裝飾者模式
中介模式
門面模式

一、中介者模式

中介者模式又叫調解者模式或調停者模式，是行為型設計模式之一。

生活中的中介者的作用就是連接兩方的一個橋梁，比如房產中介，買房的只需跟中介打交道，然后買房的也跟著中介打交道，

沒有中介的時候是這樣的：

每個買房的和賣房的都要和很多對方打交道，有了新的買房人，這些賣房的都得知道才能去和他聯系。

有了中介者之后：

所有買房的和賣房的都只需要跟中介者一個人打交道，買房的不需要知道賣房的是什么人，有多少賣房的等等。都省事了很多。

定義

通過中介者包裝一系列對象的交互，使得這些對象不必相互顯式引用，從而使它們可以松散耦合。且可以獨立地改變它們之間的交互。中介者模式又叫調停模式，它是迪米特法則的典型應用。

當某些對象之間的作用發生變化是，不會立即影響其他對象間的作用，保證這些作用協議彼此獨立的變化。

中介者模式將多對多的相互作用轉化為一對多的相互作用。

使用場景

多個對象之間的交互操作很多，每個對象的行為都依賴批次，形成網狀的多對多結構，為了防止修改一個對象時要修改很多其他對象，可以用中介者模式。

UML

Mediator: 抽象的中介者角色，定義了同事對象到中介者的接口。

ConcreteMediator：具體的中介者角色，從具體的同事對象接收消息，同時向具體的同事對象發出命令。

Colleague：抽象同事類角色，定義了中介者對象的接口，只知道中介而不知道其他同事對象。

ConcreteColleagueA，B：具體的同事類角色，每個具體同事類都知道本身在小范圍內的行為，而不知道他在大范圍中的行為。
模板代碼：

抽象的中介者：

public interface Mediator {
    void change();
}

具體的中介者：

public class ConcreteMediator implements Mediator {
    public ConcreteColleagueA concreteColleagueA;
    public ConcreteColleagueB concreteColleagueB;

    public void setConcreteColleagueA(ConcreteColleagueA concreteColleagueA) {
        this.concreteColleagueA = concreteColleagueA;
    }

    public void setConcreteColleagueB(ConcreteColleagueB concreteColleagueB) {
        this.concreteColleagueB = concreteColleagueB;
    }

    @Override
    public void change() {
        concreteColleagueA.action();
        concreteColleagueB.action();
    }
}

抽象的同事：

public abstract class Colleague {
    public Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
    public abstract void action();
}

具體的同事：

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void action() {
        System.out.println("交給中介做A的事情");
    }
}

public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void action() {
        System.out.println("交給中介做B的事情");
    }
}

二、簡單實現

以電腦為例子。CPU，顯卡，內存等零件的交互都是通過主板實現的，而且每個零件只需要做好自己的工作，不需要知道其他零件是什么。所以主板可以作為他們的中介者。

抽象的中介者：

public abstract class Mediator {
    public abstract void change(Colleague colleague);
}

具體的中介者，主板：

public class MainBoard extends Mediator {
    private CDDevice cdDevice;
    private CPU cpu;
    private GraphicsCard graphicsCard;
    private SoundCard soundCard ;
    @Override
    public void change(Colleague colleague) {
        if (colleague==cdDevice){
            handleCD((CDDevice) colleague);
        }
        if (colleague==cpu){
            handleCPU((CPU) colleague);
        }
    }
    private void handleCD(CDDevice  cdDevice){
        cpu.decodeData(cdDevice.read());
    }
    private void handleCPU(CPU cpu){
        soundCard.playSound(cpu.getDataSound());
        graphicsCard.vidoePlay(cpu.getDataVideo());
    }

    public void setCdDevice(CDDevice cdDevice) {
        this.cdDevice = cdDevice;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public void setGraphicsCard(GraphicsCard graphicsCard) {
        this.graphicsCard = graphicsCard;
    }

    public void setSoundCard(SoundCard soundCard) {
        this.soundCard = soundCard;
    }
}

抽象的零件：

public abstract class Colleague {
    public Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
}

具體的零件：

public class CPU extends Colleague {
    private String dataVideo,dataSound;
    public CPU(Mediator mediator) {
        super(mediator);
    }
    public String getDataVideo(){
        return dataVideo;
    }
    public String getDataSound() {
        return dataSound;
    }

    //解析數據，分割音頻和視頻
    public void decodeData(String data){
        String[] tmp = data.split("，");
        dataVideo=tmp[0];
        dataSound=tmp[1];
        mediator.change(this);
    }
}

public class CDDevice extends Colleague {
    private String data;
    public CDDevice(Mediator mediator) {
        super(mediator);
    }
    public String read(){
        return data;
    }
    public void load(){
        data="視頻數據，音頻數據";
        mediator.change(this);
    }
}

public class GraphicsCard extends Colleague {
    public GraphicsCard(Mediator mediator) {
        super(mediator);
    }

    public void vidoePlay(String data){
        System.out.println("播放視頻："+data);
    }
}

public class SoundCard extends Colleague {
    public SoundCard(Mediator mediator) {
        super(mediator);
    }

    public void playSound(String data){
        System.out.println("播放音頻："+ data);
    }

}

總結

如果一個系統中對象之間的聯系呈現為網狀結構，對象之間存在大量多對多關系，將導致關系及其復雜，這些對象稱為“同事對象”
-我們可以引入一個中介者對象，使各個同事對象只跟中介者對象打交道，將復雜的網絡結構化解為如下的星形結構

中介者模式

在面向對象編程中，一個類必然會與其他類產生依賴關系，當依賴關系錯綜復雜時，可以考慮用中介者模式進行解耦。

優點

降低類的關系復雜度，將多對多轉化成一對多，實現解耦。
符合迪米特原則（最少知識原則）

缺點

中介者要做很多事，會變得龐大且難以維護。
如果本來關系并不復雜，那么使用中介者可能會讓關系變得更復雜。