Java设计模式--桥接模式（Bridge）

概述

---

• 桥接模式是一种很实用的结构型设计模式，如果软件系统中某个类存在两个独立变化的维度，通过该模式可以将这两个维度分离出来，使两者可以独立扩展，让系统更加符合“单一职责原则”。与多层继承方案不同，它将两个独立变化的维度设计为两个独立的继承等级结构，并且在抽象层建立一个抽象关联，该关联关系类似一条连接两个独立继承结构的桥，故名桥接模式。
• 桥接模式用一种巧妙的方式处理多层继承存在的问题，用抽象关联取代了传统的多层继承，将类之间的静态继承关系转换为动态的对象组合关系，使得系统更加灵活，并易于扩展，同时有效控制了系统中类的个数。
• 定义：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
• 又称为柄体(Handle and Body)模式或接口(Interface)模式。
• 抽象和实现是组合的关系。利用组合替代继承。
• 是一种对象结构型模式
• 学习难度：★★★☆☆
• 使用频率：★★★☆☆

优缺点

---

• 优点
  • 抽象和实现分离
  • 替代继承
• 缺点

类图

---

组成角色

---

• 抽象角色（Abstraction）
• 实现角色（Implementor）
• 精确抽象角色（RefinedAbstraction）
• 具体实现角色（ConcreteImplementor）

Code Example

---

抽象角色（Abstraction）

/**
 * 抽象角色：它定义了抽象类的接口而且维护着一个指向实现 （Implementor）角色的引用。
 * 
 * @author yanbin
 * 
 */
public class Abstraction {

   /** 实现角色 */
   private Implementor implementor;

   public Abstraction(Implementor implementor) {
      this.implementor = implementor;
   }

   /**
    * 操作方法，核心在这边，前端的接口实现调用后端的实现。
    */
   public void operation() {
      implementor.operation();
   }

   /**
    * 用于继承类来获取实现角色
    * 
    * @return
    */
   protected Implementor getImplementor() {
      return implementor;
   }

}

实现角色（Implementor）

/**
 * 实现角色：给出了实现类的接口，这里的接口与抽象角色中的接口可以不一致。
 * 
 * @author yanbin
 * 
 */
public interface Implementor {

   public void operation();

}

精确抽象角色（RefinedAbstraction）

/**
 * 精确抽象角色：实现并扩充由抽象角色定义的接口。
 * 
 * @author yanbin
 * 
 */
public class RefinedAbstraction extends Abstraction {

   /**
    * 精确抽象，修正抽象
    * 
    * @param implementor
    */
   public RefinedAbstraction(Implementor implementor) {
      super(implementor);
   }

   public void correct() {
      System.out.println("correct method");
   }

   @Override
   public void operation() {
      getImplementor().operation();
   }

}

具体实现角色（ConcreteImplementor）

/**
 * 具体实现角色：给出了实现角色定义接口的具体实现。
 * 
 * @author yanbin
 * 
 */
public class ConcreteImplementorA implements Implementor {

   public void operation() {
      System.out.println("concrete ImplementorA operation!");
   }

}

/**
 * 具体实现角色：给出了实现角色定义接口的具体实现。
 * 
 * @author yanbin
 * 
 */
public class ConcreteImplementorB implements Implementor {

   public void operation() {
      System.out.println("concrete ImplementorB operation!");
   }

}

客户端

/**
 * 桥梁模式：将抽象部分与它的实现部分分离，使它们都可以独立地变化。抽象和实现是组合的关系。

 * 也就是说，实现部分是被抽象部分调用，以用来完成（实现） 抽象部分的功能。 

 * 组成：抽象（ Abstraction ）角色： 它定义了抽象类的接口而且维护着一个指向实现（Implementor）角色的引用。

 * 精确抽象（RefinedAbstraction）角色：实现并扩充由抽象角色定义的接口。

 * 实现（Implementor）角色：给出了实现类的接口，这里的接口与抽象角色中的接口可以不一致。

 * 具体实现（ConcreteImplementor）角色：给出了实现角色定义接口的具体实现。
 * 
 * @author yanbin
 * 
 */
public class BridgePattern {

   public static void main(String[] args) {
      Implementor implementorA = new ConcreteImplementorA();
      Abstraction abstractionA = new RefinedAbstraction(implementorA);

      Implementor implementorB = new ConcreteImplementorB();
      Abstraction abstractionB = new RefinedAbstraction(implementorB);

      implementorA.operation();
      implementorB.operation();
      abstractionA.operation();
      abstractionB.operation();
   }

}