文章目录
  1. 1. 简单介绍
  2. 2. UML图
    1. 2.1. 参与者
  3. 3. 实例
  4. 4. 输出
  5. 5. 效果
  6. 6. 与Strategy Pattern的区别
  7. 7. 与Decorator Pattern的区别

简单介绍

Bridge 模式是构造型的设计模式之一。Bridge模式基于类的最小设计原则,通过使用封装,聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽象(abstraction)与行为实现(implementation)分离开来,从而可以保持各部分的独立性以及应对它们的功能扩展。

UML图

参与者

  1. Abstraction:抽象化角色。抽象化给出的定义,并保存一个对实现化对象的引用
  2. Refined Abstraction:修正抽象化角色。扩展抽象化角色,改变和修正父类对抽象化的定义。
  3. Implementor:实现化角色。这个角色给出实现化角色的接口,但不给出具体的实现。必须指出的是,这个接口不一定和抽象化角色的接口定义相同,实际上,这两个接口可以非常不一样。实现化角色应当只给出底层操作,而抽象化角色应当只给出基于底层操作的更高一层的操作。
  4. Concrete Implementor:具体实现化角色。这个角色给出实现化角色接口的具体实现。

实例

  1. Drawing接口类

    public interface Drawing {
        public void drawLine();
        public void drawCircle();
    }
    
  2. V1Drawing类

    public class V1Drawing implements Drawing{
    
        @Override
        public void drawLine() {
            System.out.println("V1Drawing drawLine()");
        }
    
        @Override
        public void drawCircle() {
            System.out.println("V1Drawing drawCircle");
        }
    
    }
    
  3. V2Drawing类

    public class V2Drawing implements Drawing{
    
        @Override
        public void drawLine() {
            System.out.println("V2Drawing drawLine()");
        }
    
        @Override
        public void drawCircle() {
            System.out.println("V2Drawing drawCircle");
        }
    }
    
  4. Shape类

    public abstract class Shape {
        private Drawing drawing;
    
        public Shape(Drawing drawing) {
            this.drawing = drawing;
        }
    
        public abstract void draw();
        public void drawLine(){
            drawing.drawLine();
        }
        public void drawCircle() {
            drawing.drawCircle();
        }
    
        public Drawing getDrawing() {
            return drawing;
        }
    
        public void setDrawing(Drawing drawing) {
            this.drawing = drawing;
        }
    
    }
    
  5. Circle类

    public class Circle extends Shape{
        public Circle(Drawing drawing) {
            super(drawing);
            // TODO Auto-generated constructor stub
        }
    
        @Override
        public void draw() {
            System.out.println("Circle begin drawing..");
            getDrawing().drawCircle();        
        }
    
    }
    
  6. Rectangle类

    public class Rectangle extends Shape{
    
        public Rectangle(Drawing drawing) {
            super(drawing);
            // TODO Auto-generated constructor stub
        }
    
        @Override
        public void draw() {
            System.out.println("Rectangle begin drawing..");
            getDrawing().drawLine();
        }
    }
    
  7. Test类

    public class Test {
        public static void main(String arg[]) {
            Drawing drawing = new V1Drawing();
            Drawing drawing2 = new V2Drawing();
    
            Shape rectangle = new Rectangle(drawing);
            rectangle.draw();
    
            Shape circle = new Circle(drawing2);
            circle.draw();
        }
    }
    

输出

Rectangle begin drawing..
V1Drawing drawLine()
Circle begin drawing..
V2Drawing drawCircle

效果

  1. 解耦抽象和实现(Decouples interface and implementation)
  2. 提高扩展性(Improved extensibility)
  3. 隐藏实现细节(Hiding implementation details from client)

与Strategy Pattern的区别

  1. 首先,在形式上,两者还是有一定区别的,对比两幅结构图,我们可以发现,在桥接模式中不仅Implementor具有变化 (ConcreateImplementior),而且Abstraction也可以发生变化(RefinedAbstraction),而且两者的变化 是完全独立的,RefinedAbstraction与ConcreateImplementior之间松散耦合,它们仅仅通过Abstraction与 Implementor之间的关系联系起来。而在策略模式中,并不考虑Context的变化,只有算法的可替代性
  2. 其次在语意上,桥接模式强调Implementor接口仅提供基本操作,而Abstraction则基于这些基本操作定义更高层次的操作。而策略模式强调 Strategy抽象接口的提供的是一种算法,一般是无状态、无数据的,而Context则简单调用这些算法完成其操作
  3. 桥接模式中不仅定义Implementor的接口而且定义Abstraction的接口,Abstraction的接口不仅仅是为了与 Implementor通信而存在的,这也反映了结构型模式的特点:通过继承、聚合的方式组合类和对象以形成更大的结构。在策略模式中,Startegy 和Context的接口都是两者之间的协作接口,并不涉及到其它的功能接口,所以它是行为模式的一种。行为模式的主要特点就是处理的是对象之间的通信方 式,往往是通过引入中介者对象将通信双方解耦,在这里实际上就是将Context与实际的算法提供者解耦。

与Decorator Pattern的区别

Decorator是对已有功能的增强, 装饰类都是围绕被装饰类已有的功能而展开的, 无论装饰类怎么变, 它都必须围绕被装饰类来变化(或者是围绕二者公共的接口来变化), 因为对于客户程序来说, 调用装饰前后的对象应该是一致的. 而Bridge模式是将行为从被桥接对象(抽象类)中分离出去, 完全放到实现类中去实现, 行为实现将更少的受到被桥接对象的限制. 所以如果这种约束是必要的,就可以采用Decorator模式, 反之则可以采用Bridge模式

文章目录
  1. 1. 简单介绍
  2. 2. UML图
    1. 2.1. 参与者
  3. 3. 实例
  4. 4. 输出
  5. 5. 效果
  6. 6. 与Strategy Pattern的区别
  7. 7. 与Decorator Pattern的区别