Java面向对象设计之桥接模式

javazx

模式动机

设想如果要绘制矩形、圆形、椭圆、正方形，我们至少需要4个形状类，但是如果绘制的图形需要具有不同的颜色，如红色、绿色、蓝色等，此时至少有如下两种设计方案：

• 第一种设计方案是为每一种形状都提供一套各种颜色的版本。
• 第二种设计方案是根据实际需要对形状和颜色进行组合
  2 W  u% k! Y+ N2 m) Y: N) A! e1 `

对于有两个变化维度（即两个变化的原因）的系统，采用方案二来进行设计系统中类的个数更少，且系统扩展更为方便。设计方案二即是桥接模式的应用。桥接模式将继承关系转换为关联关系，从而降低了类与类之间的耦合，减少了代码编写量。

模式定义

桥接模式(Bridge Pattern)：将抽象和实现解耦，使得两者可以独立地变化。它是一种对象结构型模式，又称为桥梁模式。

模式角色

桥接模式包含如下角色：

• Abstraction：抽象类角色
• RefinedAbstraction：扩充抽象类
• Implementor：实现化角色
• ConcreteImplementor：具体实现化角色的实现类
  

UML类图
' W6 G9 f& O4 I, X

桥接模式UML
; ^  c. V6 X+ a* R, P& z

代码示例

首先，是实现化角色Abstraction类：

1. /**
   
2. * 实现化角色 Implementor.
   - K7 O! k7 c; _0 y4 i% M/ S' |
3. *
   
4. * @author blinkfox on 2018-12-17.
   
5. */
   ; I' N- V4 _, d3 w' ~# o1 R  o
6. public interface Implementor {
   + ~7 [" a: w% h& Q' P9 x- s
7. 
   
8.     /**
   
9.      * 基本方法1.
   * e1 S$ c5 p5 I$ a* Z1 K
10.      */
    
11.     void doSomething();
    
12. 
    
13.     /**
    
14.      * 基本方法2.
    ; L% ^6 t: M. M8 U7 |
15.      */
    
16.     void doAnything();
    
17. 
    
18. }

复制代码

然后，是各个具体的实现化角色类：

1. /**
   
2. * ConcreteImplementor1.
   4 B# m+ V' j9 h" u
3. *
   
4. * @author blinkfox on 2018-12-17.
   
5. */
   
6. public class ConcreteImplementor1 implements Implementor {
   
7. 
   
8.     /**
   
9.      * 基本方法1.
   
10.      */
    . ]% P9 B4 V. K8 w9 ]
11.     @Override
    
12.     public void doSomething() {
    . v3 `( K5 @  j: U$ {: s. ?% k
13.         System.out.println("ConcreteImplementor1 的业务逻辑 doSomething.");
    
14.     }
    & h8 s6 [' g! d* v) e' i
15. 
    
16.     /**
    
17.      * 基本方法2.
    , X. S( Z! O) A+ ~, O& h" o5 h; j
18.      */
    
19.     @Override
    
20.     public void doAnything() {
    1 V) }5 H  z: B9 q, H
21.         System.out.println("ConcreteImplementor1 的业务逻辑 doAnything.");
    , Y$ Z4 g/ K1 ?
22.     }
    
23. 
    $ y% L( U& W! ^
24. }

复制代码

1. /**
   + n& H- s- `6 e, I( C  E
2. * ConcreteImplementor2.
   ' n5 a1 n2 e/ H' E# A6 p: L! I
3. *
   5 f3 e2 C7 o* _+ K4 V& F& E
4. * @author blinkfox on 2018-12-17.
   + j6 s2 g0 i1 \( H4 A
5. */
   ( S0 H0 e, d+ e( j. K. p) {2 i) l
6. public class ConcreteImplementor2 implements Implementor {
   % c& X9 s5 {# \9 Y" E0 F
7. 
   ; O) q4 J; d+ Q8 M
8.     /**
   
9.      * 基本方法1.
   
10.      */
    0 p% V' b0 R. a4 {& @- A
11.     @Override
    
12.     public void doSomething() {
    
13.         System.out.println("ConcreteImplementor2 的业务逻辑 doSomething.");
    0 e4 ^0 u2 W: I, `) g. f. ^& H
14.     }
    $ a1 T# J: Q# m$ M
15. 
    7 x- F. X7 U1 H5 a
16.     /**
    
17.      * 基本方法2.
    + c, A- A9 ?0 z
18.      */
    " b' m, O1 Q. L4 Q7 D4 v0 M
19.     @Override
    # _0 y. q( n/ _0 [) d( \6 P1 F
20.     public void doAnything() {
    
21.         System.out.println("ConcreteImplementor2 的业务逻辑 doAnything.");
    9 R& j, y% V/ m5 q( \
22.     }
    5 f6 @) r# [+ t% L- E
23. 
    4 A# P7 X" T4 i/ u6 J+ E! o4 w
24. }

复制代码

* R, e8 x3 c# P; ?. C+ g

接下来，是抽象类角色Abstraction类：

1. package com.blinkfox.patterns.bridge;
   
2. 
   
3. /**
   
4. * 抽象化角色 Abstraction.
   7 {# N$ S  U* W* i4 [, Q, ^
5. *
   
6. * @author blinkfox on 2018-12-17.
   
7. */
   + O% B/ t% N7 _
8. public abstract class Abstraction {
   : c8 K2 i# N- e0 z3 m( L8 V
9. 
   % o, B3 y! i& d" |# d) N3 Y
10.     /** 定义对实现化角色的引用. */
    
11.     private Implementor impl;
    
12. 
    5 h# ]: _) `4 w  D& O
13.     /**
    
14.      * 构造方法.
    / x' R2 m! H4 O1 l* H1 a( z+ ~
15.      *
    
16.      * @param impl 实现类的实例
    9 |" t, r/ e+ @' ^" O: f3 B6 [
17.      */
    
18.     public Abstraction(Implementor impl) {
    $ l# |+ M0 {$ x3 j
19.         this.impl = impl;
    8 P$ ^3 @) z$ }7 t  |  R. V
20.     }
    
21. 
    
22.     /**
    
23.      * impl 的 getter方法.
    
24.      *
    5 `' v; n# l* C. b. U
25.      * @return impl
    " |9 P' J4 u* k3 n& j2 B
26.      */
    7 {1 \3 H9 `9 D0 e9 Q& I7 ~% [
27.     public Implementor getImpl() {
    6 W$ N' P& g$ F" ?
28.         return impl;
    % G9 m4 J( \8 }. K" `
29.     }
    & T) z' v; o' y2 M
30. 
    
31.     /**
    
32.      * 自身的请求处理方法.
    3 h+ l8 ?& Z6 z" p
33.      */
    , L6 j. c; z" ?
34.     public void request() {
      }1 K0 V, D; {2 n# p0 D* |
35.         this.impl.doSomething();
    
36.     }
    & V4 n4 i  h- b* B
37. 
    / [  q7 \6 f* O" l
38. }

复制代码

. s( u- v4 D, ^2 @/ @1 t

再次，是扩展的具体抽象化角色类RefinedAbstraction：

1. /**
   
2. * RefinedAbstraction.
   
3. *
   
4. * @author blinkfox on 2018-12-17.
   
5. */
   ! u# P8 y  W, ]( x0 {
6. public class RefinedAbstraction extends Abstraction {
   8 t: e( a7 C, N+ @2 [0 p7 h$ }
7. 
   
8.     /**
   
9.      * 构造方法.
   6 m3 N' ~& q, h
10.      *
    1 C' Z. z7 \" F! f
11.      * @param impl 实现类的实例
    
12.      */
    9 T  Z2 B) t; Y
13.     public RefinedAbstraction(Implementor impl) {
    8 V, b1 P) C, N5 Z* }
14.         super(impl);
    7 s& v+ e+ L$ S! r
15.     }
    / w8 m$ S5 }5 H' k8 Z
16. 
    9 v8 c) P' `! o/ @3 _7 \4 C( g/ H
17.     /**
    . @$ X) e- X; y  {' M
18.      * 覆盖后的请求处理方法.
    6 ^; }. M: ?& x* Z8 u
19.      */
    7 I- |5 Q0 |: Q' A$ ?0 g0 O8 H* G
20.     @Override
    6 U! w- b& `4 L9 N
21.     public void request() {
    % D  t/ h, i( c6 S9 k) ^
22.         System.out.println("RefinedAbstraction 开始做业务处理.");
    9 F5 W3 w  t/ p7 N: |
23.         super.request();
    
24.         super.getImpl().doAnything();
    * S$ e0 u& V0 `% S% V3 S
25.     }
    
26. 
    
27. }

复制代码

最后，是客户端场景类：

1. /**
   * C8 s, p' `4 x
2. * Client.
   
3. *
   3 q8 @: |/ F1 {, M
4. * @author blinkfox on 2018-12-17.
   
5. */
   0 T9 }3 O* d# d5 f5 m" J
6. public class Client {
   ; u$ s* i. p: y, W
7. 
   
8.     /**
   " V% A  [- X( H* {2 I
9.      * main方法.
   
10.      *
    
11.      * @param args 数组参数
    
12.      */
    
13.     public static void main(String[] args) {
    
14.         // 定义一个实现化角色和抽象化角色,并执行请求方法.
    3 I+ l$ K4 S7 u! A( O2 ~
15.         Implementor impl = new ConcreteImplementor1();
    
16.         Abstraction abs = new RefinedAbstraction(impl);
    
17.         abs.request();
    $ i4 t% L. ]+ Q) H) w% s
18.     }
    4 [; l) M6 E. w7 A/ e# X! E6 @
19. 
    
20. }

复制代码

模式分析

理解桥接模式，重点需要理解如何将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化。

• 抽象化：抽象化就是忽略一些信息，把不同的实体当作同样的实体对待。在面向对象中，将对象的共同性质抽取出来形成类的过程即为抽象化的过程。
• 实现化：针对抽象化给出的具体实现，就是实现化，抽象化与实现化是一对互逆的概念，实现化产生的对象比抽象化更具体，是对抽象化事物的进一步具体化的产物。
• 脱耦：脱耦就是将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联，将两个角色之间的继承关系改为关联关系。桥接模式中的所谓脱耦，就是指在一个软件系统的抽象化和实现化之间使用关联关系（组合或者聚合关系）而不是继承关系，从而使两者可以相对独立地变化，这就是桥接模式的用意。
  

优点

桥接模式的优点:

• 分离抽象接口及其实现部分。
• 桥接模式有时类似于多继承方案，但是多继承方案违背了类的单一职责原则（即一个类只有一个变化的原因），复用性比较差，而且多继承结构中类的个数非常庞大，桥接模式是比多继承方案更好的解决方法。
• 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
• 实现细节对客户透明，可以对用户隐藏实现细节。
  ; O( |$ R6 A1 ~0 C

缺点

桥接模式的缺点:

• 桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。
• 桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围具有一定的局限性。
  

适用环境

在以下情况下可以使用桥接模式：

• 如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。
• 抽象化角色和实现化角色可以以继承的方式独立扩展而互不影响，在程序运行时可以动态将一个抽象化子类的对象和一个实现化子类的对象进行组合，即系统需要对抽象化角色和实现化角色进行动态耦合。
• 一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。
• 虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。
• 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。
  

模式应用

一个Java桌面软件总是带有所在操作系统的视感(LookAndFeel)，如果一个Java软件是在Unix系统上开发的，那么开发人员看到的是Motif用户界面的视感；在Windows上面使用这个系统的用户看到的是Windows用户界面的视感；而一个在Macintosh上面使用的用户看到的则是Macintosh用户界面的视感，Java语言是通过所谓的Peer架构做到这一点的。Java为AWT中的每一个GUI构件都提供了一个Peer构件，在AWT中的Peer架构就使用了桥接模式。

模式扩展

适配器模式与桥接模式的联用:

桥接模式和适配器模式用于设计的不同阶段，桥接模式用于系统的初步设计，对于存在两个独立变化维度的类可以将其分为抽象化和实现化两个角色，使它们可以分别进行变化；而在初步设计完成之后，当发现系统与已有类无法协同工作时，可以采用适配器模式。但有时候在设计初期也需要考虑适配器模式，特别是那些涉及到大量第三方应用接口的情况。

总结

• 桥接模式将抽象部分与它的实现部分分离，使它们都可以独立地变化。它是一种对象结构型模式。
• 桥接模式包含如下四个角色：抽象类中定义了一个实现类接口类型的对象并可以维护该对象；扩充抽象类扩充由抽象类定义的接口，它实现了在抽象类中定义的抽象业务方法，在扩充抽象类中可以调用在实现类接口中定义的业务方法；实现类接口定义了实现类的接口，实现类接口仅提供基本操作，而抽象类定义的接口可能会做更多更复杂的操作；具体实现类实现了实现类接口并且具体实现它，在不同的具体实现类中提供基本操作的不同实现，在程序运行时，具体实现类对象将替换其父类对象，提供给客户端具体的业务操作方法。
• 在桥接模式中，抽象化(Abstraction)与实现化(Implementation)脱耦，它们可以沿着各自的维度独立变化。
• 桥接模式的主要优点是分离抽象接口及其实现部分，是比多继承方案更好的解决方法，桥接模式还提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统，实现细节对客户透明，可以对用户隐藏实现细节；其主要缺点是增加系统的理解与设计难度，且识别出系统中两个独立变化的维度并不是一件容易的事情。
• 桥接模式适用情况包括：需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系；抽象化角色和实现化角色可以以继承的方式独立扩展而互不影响；一个类存在两个独立变化的维度，且这两个维度都需要进行扩展；设计要求需要独立管理抽象化角色和具体化角色；不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统。
  ' O) r. Y* t; ]- I- X

ajiaayun

佩服佩服！

hgwsm

不错 支持下

824006725

努力学习努力学习努力学习

panic55

非常好，顶一下

q1123109165

哈哈哈哈哈，开心

java

好资源

wtwrt

好资源

aystzh

即将学习之路