【设计模式】用Java实现桥接模式_java桥接模式的应用场景

一.桥接模式介绍与使用场景

桥接模式是一种结构设计模式，用于将抽象部分与其具体实现部分分离，使它们能够独立地变化。桥接模式通过使用接口和实现类之间的组合关系，而不是继承关系，来实现这种分离。

桥接模式的核心思想是将抽象部分和实现部分分开，使它们可以独立地变化。抽象部分定义了高层的抽象接口，而实现部分定义了底层的具体实现。通过桥接模式，可以在不修改抽象部分的情况下，动态地切换和扩展实现部分。

桥接模式适用场景：

1. 当需要将一个类的抽象部分和实现部分分离，并且让它们能够独立地变化时，可以使用桥接模式。这样可以使抽象部分和实现部分可以独立地进行扩展和修改，而不会相互影响。

2. 当一个类存在多个维度的变化，且每个维度都可以独立地进行扩展时，可以使用桥接模式。通过桥接模式，可以避免类的爆炸性增长，将各个维度的变化分离开来，使系统更加灵活。

3. 当需要在运行时动态切换和组合对象的不同部分时，可以使用桥接模式。桥接模式可以通过组合关系来替代继承关系，使对象的不同部分可以自由地组合和切换，增加了系统的灵活性。

4. 当需要对一个抽象的实现部分进行扩展，并且不希望对其他已有的抽象部分产生影响时，可以使用桥接模式。桥接模式允许对抽象部分和实现部分进行独立的扩展，而不会相互影响。

在实际开发中，桥接模式常见于以下场景：

• 在图形用户界面(GUI)开发中，可以使用桥接模式将不同操作系统的窗口组件抽象出来，并与不同的UI工具包进行组合，实现跨平台的窗口界面。

• 在汽车制造业中，可以使用桥接模式将汽车的品牌和型号分离开来。品牌和型号可以独立变化，通过桥接模式可以动态地组合不同的品牌和型号。

• 在游戏开发中，可以使用桥接模式将游戏角色的技能和装备分离开来。角色的技能和装备可以独立变化，通过桥接模式可以动态地组合不同的技能和装备。

总的来说，桥接模式适用于需要将抽象部分和实现部分分离、具有多维度变化或需要动态切换和组合对象部分的场景。通过桥接模式，可以使系统更加灵活、可扩展，并且降低了类之间的耦合度。

二.桥接模式实现

下面用一个简单的demo描述一下桥接模式：

// 抽象部分 - 形状
abstract class Shape {
    protected DrawingAPI drawingAPI;
 
    public Shape(DrawingAPI drawingAPI) {
        this.drawingAPI = drawingAPI;
    }
 
    public abstract void draw();
}
 
// 实现部分 - 绘图API
interface DrawingAPI {
    void drawCircle(double x, double y, double radius);
}
 
// 具体实现部分A - 绿色圆形
class GreenCircle implements DrawingAPI {
    public void drawCircle(double x, double y, double radius) {
        System.out.printf("Drawing green circle at (%.1f, %.1f) with radius %.1f%n", x, y, radius);
    }
}
 
// 具体实现部分B - 红色圆形
class RedCircle implements DrawingAPI {
    public void drawCircle(double x, double y, double radius) {
        System.out.printf("Drawing red circle at (%.1f, %.1f) with radius %.1f%n", x, y, radius);
    }
}
 
// 扩展抽象部分 - 圆形
class Circle extends Shape {
    private double x, y, radius;
 
    public Circle(double x, double y, double radius, DrawingAPI drawingAPI) {
        super(drawingAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }
 
    public void draw() {
        drawingAPI.drawCircle(x, y, radius);
    }
}
 
// 使用示例
public class Main {
    public static void main(String[] args) {
        DrawingAPI greenAPI = new GreenCircle();
        Shape greenCircle = new Circle(100, 100, 50, greenAPI);
        greenCircle.draw();
 
        DrawingAPI redAPI = new RedCircle();
        Shape redCircle = new Circle(200, 200, 100, redAPI);
        redCircle.draw();
    }
}

在上述示例中，我们模拟了一个绘制圆形的场景。Shape 是抽象部分，定义了绘制图形的接口。DrawingAPI 是实现部分，定义了具体的绘图方法。

具体实现部分A和具体实现部分B分别是绿色圆形和红色圆形的具体实现。它们实现了DrawingAPI 接口，并提供了具体的绘图逻辑。

Circle 是扩展抽象部分，它继承自Shape，并在构造函数中接收一个DrawingAPI 对象。Circle 类在实现绘制方法时，通过调用DrawingAPI 的方法来实现具体的绘图操作。

在Main 类的main 方法中，我们创建了绿色圆形和红色圆形的对象，并调用它们的draw 方法。根据传入的DrawingAPI 对象不同，圆形对象将使用不同的具体实现部分来完成绘制操作。

除了上面这个简单的demo外，我们再来写一个更加贴近实际开发场景的demo，例如实现一个会员用户和一个普通用户在购买商品时，会调用不同的支付网关来处理支付操作。

// 抽象部分 - 用户
abstract class User {
    protected PaymentGateway paymentGateway;
 
    public User(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
 
    public abstract void purchase(double amount);
}
 
// 实现部分 - 支付网关
interface PaymentGateway {
    void processPayment(double amount);
}
 
// 具体实现部分A - 支付宝支付
class Alipay implements PaymentGateway {
    public void processPayment(double amount) {
        System.out.println("Processing payment via Alipay: $" + amount);
    }
}
 
// 具体实现部分B - 微信支付
class WeChatPay implements PaymentGateway {
    public void processPayment(double amount) {
        System.out.println("Processing payment via WeChat Pay: $" + amount);
    }
}
 
// 扩展抽象部分 - 会员用户
class PremiumUser extends User {
    public PremiumUser(PaymentGateway paymentGateway) {
        super(paymentGateway);
    }
 
    public void purchase(double amount) {
        System.out.println("Premium user is making a purchase...");
        paymentGateway.processPayment(amount * 0.9); // 享受9折优惠
    }
}
 
// 扩展抽象部分 - 普通用户
class RegularUser extends User {
    public RegularUser(PaymentGateway paymentGateway) {
        super(paymentGateway);
    }
 
    public void purchase(double amount) {
        System.out.println("Regular user is making a purchase...");
        paymentGateway.processPayment(amount);
    }
}
 
// 使用示例
public class Main {
    public static void main(String[] args) {
        PaymentGateway alipay = new Alipay();
        PaymentGateway weChatPay = new WeChatPay();
 
        User premiumUser = new PremiumUser(alipay);
        premiumUser.purchase(100);
 
        User regularUser = new RegularUser(weChatPay);
        regularUser.purchase(50);
    }
}

我们模拟了一个电商系统中的用户购买商品的场景。User 是抽象部分，定义了用户的行为接口。PaymentGateway 是实现部分，定义了支付网关的处理方法。

具体实现部分A和具体实现部分B分别是支付宝支付和微信支付的具体实现。它们实现了PaymentGateway 接口，并提供了具体的支付逻辑。

PremiumUser 和 RegularUser 是扩展抽象部分，它们继承自 User，并在购买方法中调用相应的支付网关来处理支付操作。

在 Main 类的 main 方法中，我们创建了支付宝和微信支付的支付网关对象，然后分别创建了一个会员用户和一个普通用户，并传入不同的支付网关对象。用户对象在购买商品时，会调用相应的支付网关来处理支付操作。

通过使用桥接模式，我们将用户和支付网关两个维度进行了分离，使它们能够独立地变化。这样一来，我们可以方便地增加新的支付网关实现，同时也能在不修改用户对象的情况下切换和扩展支付网关。桥接模式能够提高系统的灵活性和可扩展性，并且符合面向对象设计的开闭原则。