首先 ，我們來復現(xiàn)問題。然后再去根據(jù)問題 解決問題。

場景：

我們現(xiàn)在有個消息站，需要去推送消息，消息的類型有：普通消息。
消息發(fā)送方法有：短信發(fā)送。

新建發(fā)送消息接口：

/**
 * 發(fā)送消息接口
 * @author Biao
 *
 */
public interface Message {
    /**
     * 發(fā)送消息
     * @param message 要發(fā)送的消息內(nèi)容
     * @param to 消息的接收者
     */
    void send(String message,String to);
}

發(fā)送普通短信消息的類

/**
 * 短信模式短消息
 * 
 * @author Biao
 *
 */
public class CommonMessageSMS implements Message {

    @Override
    public void send(String message, String to) {
        System.out.println("發(fā)送普通短信短消息：" + message + "，給" + to);
    }

}

現(xiàn)在需求變更：需要添加一個加急的短信消息

我們先做加急消息的接口

/**
 * 加急消息的抽象接口
 * 
 * @author Biao
 *
 */
public interface UrgencyMessage extends Message {
    /**
     * 監(jiān)控消息的處理（區(qū)分普通消息）
     * 
     * @param messageId
     *            消息編號
     */
    void watch(String messageId);

}

加急短信消息類

/**
 * 加急短信消息
 * 
 * @author Biao
 *
 */
public class UrgencyMessageSMS implements UrgencyMessage {
    @Override
    public void watch(String messageId) {
        // 加急處理方法
    }

    @Override
    public void send(String message, String to) {
        System.out.println("發(fā)送加急短信消息：" + message + "，給" + to);
    }

}

需求再次變更：需要添加 加急郵箱消息和普通郵箱消息

這時我們需要添加2個類 一個普通郵箱消息類 一個加急郵箱消息類 如果需求再次變更 需要添加一個特急消息。 特急消息需要有短信、郵箱 、微信消息 并且 普通消息 加急消息都要添加 。
我們的類圖現(xiàn)在是這樣：

上面就畫了兩種消息。還有一種也是一樣這個時候我們項目擁有12個類 以后每添加一種消息類型 比如 微博消息 這時候我們需要多添加3個類，如果我們在添加一個超特急消息呢。是不是要死人了哈哈~ 這個時候就要用到我們的橋接模式了。

橋接模式定義：

將抽象部分與它的實現(xiàn)部分分離，使它們都可以獨立地變化。

使用場景

在軟件系統(tǒng)中，某些類型由于自身的邏輯，它具有兩個或多個維度的變化，那么如何應對這種“多維度的變化”？如何利用面向對象的技術來使得該類型能夠輕松的沿著多個方向進行變化，而又不引入額外的復雜度？這就要使用Bridge模式。

模板代碼

我們先看橋接模式的模板代碼
抽象部分-Abstraction：

//持有實現(xiàn)部分的引用
    private Implementor implementor;
    public Abstraction(Implementor implementor) {
        this.implementor = implementor;
    }
    /**
     * 通過調(diào)用實現(xiàn)部分具體的方法實現(xiàn)具體的功能
     */
    public void operation(){
        implementor.operationImpl();
    }

再來兩個具體的實現(xiàn)

public class ConcreteImplementorA implements Implementor{

    @Override
    public void operationImpl() {
        //具體的實現(xiàn)
    }

}

public class ConcreteImplementorB implements Implementor{

    @Override
    public void operationImpl() {
        //具體的實現(xiàn)
    }

}

實現(xiàn)部分：

public interface Implementor {

    /**
     * 實現(xiàn)抽象部分的具體方法
     */
    void operationImpl();
    
}

具體的擴展

public class RefinedAbstraction extends Abstraction{

    public RefinedAbstraction(Implementor implementor) {
        super(implementor);
    }
    
    
    public void refinedOperation(){
        //對Abstraction 中的方法擴展
    }

}

具體使用

好了 到這里大家差不多明白了吧，那么我們來拿上面的案例來具體使用下這個設計模式：
先來一個抽象的消息-AbstractMessage：

public abstract class AbstractMessage {

    //持有發(fā)送消息方式的引用（實現(xiàn)部分的引用）
    protected MessageImplementor implementor;

    public AbstractMessage(MessageImplementor implementor) {
        super();
        this.implementor = implementor;
    }
    
    /**
     * 發(fā)送消息
     * @param message
     * @param to
     */
    public void sendMessage(String message,String to){
        implementor.send(message, to);
    }
    
}

消息的實現(xiàn)：

public interface MessageImplementor {

    /**
     * 發(fā)送消息
     * @param message
     * @param to
     */
    void send(String message,String to);
    
}

有了消息 我們來個消息的實現(xiàn)吧：

public class CommonMessage extends AbstractMessage {

    public CommonMessage(MessageImplementor implementor) {
        super(implementor);
    }

}

發(fā)送一個郵件消息：

public class MessageEmail implements MessageImplementor {

    @Override
    public void send(String message, String to) {
        System.out.println("發(fā)送郵件消息："+message+"，給"+to);
    }

}

發(fā)送一個手機消息：

public class MessageMobile implements MessageImplementor {

    @Override
    public void send(String message, String to) {
        System.out.println("發(fā)送手機消息："+message+"，給"+to);
    }

}

來個特急消息的類型：

public class SpecialUrgencyMessage extends AbstractMessage {

    public SpecialUrgencyMessage(MessageImplementor implementor) {
        super(implementor);
    }

    public void hurry(){
        
    }
}

來個加急消息的類型：

public class UrgencyMessage extends AbstractMessage {

    public UrgencyMessage(MessageImplementor implementor) {
        super(implementor);
    }
    
    /**
     * 監(jiān)控
     * @param messageId
     */
    public void watch(String messageId){
        
    }

}

案例很簡單。但是實際使用可能會有點復雜。
橋接模式的定義是：
將抽象部分與它的實現(xiàn)部分分離，使它們都可以獨立地變化。
那么 那個可以定義為抽象部分那個部分可以定義為實現(xiàn)部分呢。
根據(jù)上面的案例 發(fā)送消息的類型可能會不斷的增加。而且增加的頻率可能會高。那么消息類型 可能增加緩慢。那么我就把增加緩慢的定義為抽象的。

簡單來說：主動地定義為實現(xiàn)的，被動的定義為抽象的

我們再來一個案例來實踐下吧!
我們?nèi)ズ瓤Х?咖啡有大杯的有小杯的。有加糖的。有不加糖的，有加奶的，有不加奶的。那么我們來分析這個那部分是抽象的那部分是實現(xiàn)的呢？
先看案例：
先來抽象咖啡類，持有添加什么類型的引用

public abstract class Coffee {

    // 持有實現(xiàn)部分的引用
    protected CoffeeAdditives impl;

    public Coffee(CoffeeAdditives impl) {
        super();
        this.impl = impl;
    }

    /**
     * 咖啡具體做成了什么樣子由子類決定
     */
    public abstract void makeCoffee();
}

咖啡需要添加的東西：

public abstract class CoffeeAdditives {

    /**
     * 添加方法
     * @return
     */
    public abstract String add();
    
}

先來大杯咖啡：

public class LargeCoffee extends Coffee{

    public LargeCoffee(CoffeeAdditives impl) {
        super(impl);
    }

    @Override
    public void makeCoffee() {
        System.out.println("大杯的"+impl.add()+"咖啡");
    }

}

加的東西：

public class Milk extends CoffeeAdditives {

    @Override
    public String add() {
        return "加奶";
    }

}

小杯咖啡：

public class SmallCoffee extends Coffee{

    public SmallCoffee(CoffeeAdditives impl) {
        super(impl);
    }

    @Override
    public void makeCoffee() {
        System.out.println("小杯的"+impl.add()+"咖啡");
    }

}

好了 這個設計模式很簡單。具體使用還需要多練習！