设计模式之-桥梁模式，快速掌握桥梁模式，通俗易懂的讲解桥梁模式以及它的使用场景

大家好，欢迎来到IT知识分享网。

一、快速掌握桥梁模式

设计模式中的桥梁模式（Bridge Pattern）是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化。桥梁模式的核心思想是通过组合而不是继承来实现不同维度的变化。

通俗地说，桥梁模式就像是一座桥，将两个不同的维度连接在一起。其中，一个维度是抽象部分（Abstraction），它定义了高层业务逻辑，并包含对实现部分的引用；另一个维度是实现部分（Implementation），它定义了底层实现的接口。

通过桥梁模式，我们可以在两个维度上独立地变化和扩展，而不会相互影响。这种解耦的设计使得系统更加灵活，易于维护和扩展。

二、使用场景

1. 当一个类存在两个独立变化的维度时，使用桥梁模式可以将这两个维度进行解耦，使得它们可以独立地变化。
2. 当需要在多个对象间共享实现时，使用桥梁模式可以减少子类的数量，提高系统的可扩展性。
3. 当一个类需要在运行时切换不同的实现时，桥梁模式可以实现运行时的动态切换。

三、代码示例

下面是一个简单的示例代码来说明桥梁模式的应用：

// 实现部分接口 interface DrawingAPI { 
     void drawCircle(double x, double y, double radius); } // 具体的实现部分 class DrawingAPI1 implements DrawingAPI { 
     @Override public void drawCircle(double x, double y, double radius) { 
     System.out.printf("API1.drawCircle at (%.2f, %.2f) with radius %.2f%n", x, y, radius); } } // 具体的实现部分 class DrawingAPI2 implements DrawingAPI { 
     @Override public void drawCircle(double x, double y, double radius) { 
     System.out.printf("API2.drawCircle at (%.2f, %.2f) with radius %.2f%n", x, y, radius); } } // 抽象部分 abstract class Shape { 
     protected DrawingAPI drawingAPI; protected Shape(DrawingAPI drawingAPI) { 
     this.drawingAPI = drawingAPI; } public abstract void draw(); } // 具体的抽象部分 class CircleShape extends Shape { 
     private double x, y, radius; public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI) { 
     super(drawingAPI); this.x = x; this.y = y; this.radius = radius; } @Override public void draw() { 
     drawingAPI.drawCircle(x, y, radius); } } public class BridgePatternExample { 
     public static void main(String[] args) { 
     Shape redCircle = new CircleShape(100, 100, 10, new DrawingAPI1()); Shape greenCircle = new CircleShape(200, 200, 20, new DrawingAPI2()); redCircle.draw(); greenCircle.draw(); } } 

在上述示例中，我们使用桥梁模式实现了一个简单的图形绘制系统。DrawingAPI接口定义了绘制图形的方法，有两个具体的实现类DrawingAPI1和DrawingAPI2。Shape是抽象部分的基类，它包含了对实现部分的引用，并定义了抽象的绘制方法draw()。CircleShape继承了Shape，并通过构造函数将实现部分的对象传递进去。最后，在main方法中创建了两个具体的图形对象，并调用它们的draw()方法来绘制图形。

五、 桥梁模式的优点包括：

1. 解耦性高：桥梁模式将抽象部分和实现部分分离，使它们可以独立地变化。这样一来，对于抽象部分的修改不会影响到实现部分，反之亦然。这种解耦性可以提高系统的灵活性和可维护性。
2. 扩展性强：通过桥梁模式，我们可以在两个维度上独立地扩展和变化。增加新的抽象部分或实现部分都相对容易，而且它们可以在运行时动态地组合和切换。
3. 提高可复用性：由于抽象部分和实现部分可以独立地变化，可以更灵活地组合它们，从而提高代码的可复用性。

桥梁模式的缺点包括：

1. 增加了系统的复杂性：桥梁模式需要额外的抽象和实现类，并引入了额外的接口和关联关系，这可能增加系统的复杂性。
2. 增加了代码量：相比直接继承实现类的方式，桥梁模式需要编写更多的代码，包括抽象部分和实现部分的类以及它们之间的关系。

总的来说，桥梁模式适用于存在多个独立变化维度的情况，或者需要在运行时切换不同实现的情况。它可以帮助我们实现更灵活、可扩展和可复用的系统设计。

听一个故事来讲解桥梁模式，加深理解

假设有一个小镇上有两座相距很远的桥，分别是一座木桥和一座石桥。这两座桥分别代表了抽象部分和实现部分。每天早上，人们都要从小镇的一侧过桥去另一侧工作。

某天，小镇的镇长决定要修建一座新的桥，以便提供更多的通行便利性。为了实现这个目标，他决定使用桥梁模式。

镇长找来一个桥梁设计师，设计师告诉镇长，他可以设计一座新桥的抽象部分，即桥的结构和功能，不管是木桥还是石桥都可以。设计师还告诉镇长，他可以与两个工程师合作，一个擅长建造木桥，另一个擅长建造石桥。这两个工程师代表了实现部分。

设计师设计了一个抽象的桥模型，包含了通行的功能。然后，他与木桥工程师和石桥工程师一起合作，让他们根据设计制造出具体的桥。木桥工程师根据抽象模型建造了一座木桥，石桥工程师根据同样的抽象模型建造了一座石桥。

完成后，镇长和设计师非常高兴。现在，无论是木桥还是石桥，都可以作为新桥的实现部分。人们可以根据需要选择在哪座桥上通行，而不受具体桥的类型影响。

这个故事中的小镇和桥就是一个典型的应用场景。小镇代表了整个系统，而抽象部分是桥的结构和功能，实现部分则是具体的木桥和石桥。设计师就是桥梁模式的核心，他将抽象部分和实现部分分离，并协调它们的工作。通过桥梁模式，小镇的系统变得更加灵活和可扩展，可以根据需要选择不同的实现部分。

代码示例：

// 实现部分接口 interface Bridge { 
     void cross(); } // 具体的实现部分 class WoodenBridge implements Bridge { 
     @Override public void cross() { 
     System.out.println("Crossing the wooden bridge."); } } // 具体的实现部分 class StoneBridge implements Bridge { 
     @Override public void cross() { 
     System.out.println("Crossing the stone bridge."); } } // 抽象部分 abstract class Town { 
     protected Bridge bridge; protected Town(Bridge bridge) { 
     this.bridge = bridge; } public abstract void visit(); } // 具体的抽象部分 class MorningTown extends Town { 
     public MorningTown(Bridge bridge) { 
     super(bridge); } @Override public void visit() { 
     System.out.println("Visiting the town in the morning."); bridge.cross(); } } // 具体的抽象部分 class EveningTown extends Town { 
     public EveningTown(Bridge bridge) { 
     super(bridge); } @Override public void visit() { 
     System.out.println("Visiting the town in the evening."); bridge.cross(); } } public class BridgePatternExample { 
     public static void main(String[] args) { 
     Bridge woodenBridge = new WoodenBridge(); Bridge stoneBridge = new StoneBridge(); Town morningTown = new MorningTown(woodenBridge); Town eveningTown = new EveningTown(stoneBridge); morningTown.visit(); eveningTown.visit(); } } 

在上述示例代码中，我们使用桥梁模式实现了一个简单的小镇和桥的系统。Bridge接口定义了桥的通行方法，有两个具体的实现类WoodenBridge和StoneBridge，分别表示木桥和石桥。Town是抽象部分的基类，它包含了对桥实现部分的引用，并定义了抽象的访问方法visit()。MorningTown和EveningTown继承了Town，并通过构造函数将实现部分的对象传递进去。最后，在main方法中创建了具体的小镇和桥对象，并调用它们的visit()方法来模拟访问小镇。