How to use the Java bridge design pattern to elegantly separate abstraction from implementation

Introduction

Java bridge pattern (also called bridge pattern) (Bridge Pattern) is a design pattern that separates abstraction and implementation so that they can change independently. It passes a large class or a This separation is accomplished by splitting a series of closely related classes into two separate hierarchies, one containing abstract classes or interfaces and the other containing implementation classes. The Bridge pattern allows abstract classes and implementation classes to vary independently. , thereby achieving loose coupling.

In Java, the bridge pattern usually uses interfaces to define abstract parts, uses abstract classes to implement partial implementations, and combines them through combination. The abstract part contains only If you want to implement part of the reference, the implementation part implements the interface defined in the abstract part.

The Java bridge mode is divided into the following four roles:

• Abstraction role (Abstraction) : Define an abstracted interface and maintain a reference to the implemented object.

• Extended abstract role (Refined Abstraction): Extended abstract role, usually a subclass of abstract role , implement the business methods in the abstract role.

• Implementation role (Implementor): Define the interface of the implementation role. This interface does not have to be completely consistent with the interface of the abstract role. In fact, these two interfaces can be completely different.

• Concrete Implementor: Concrete Implementor implements the implemented role interface and completes specific business logic.

Implementation

For example, in an e-commerce website, it may be necessary to support multiple support methods, such as Alipay, WeChat payment and UnionPay payment. Using the bridge mode can easily Add or switch different payment methods to meet user needs.

implementation role

public interface PaymentImplementor {
    /**
     * 支付
     *
     * @param amount
     */
    void processPayment(double amount);
}

concrete implementation role

public class AliPaymentImplementor implements PaymentImplementor {
    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void processPayment(double amount) {
        System.out.println("支付宝支付:" + amount + "元...");
    }
}
public class WechatPaymentImplementor implements PaymentImplementor {
    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void processPayment(double amount) {
        System.out.println("微信支付:" + amount + "元...");
    }
}
public class UnionpayPaymentImplementor implements PaymentImplementor {
    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void processPayment(double amount) {
        System.out.println("银联支付:" + amount + "元...");
    }
}

abstract role

public abstract class Payment {
    protected PaymentImplementor implementor;
    public Payment(PaymentImplementor implementor) {
        this.implementor = implementor;
    }
    /**
     * 支付
     *
     * @param amount
     */
    public abstract void pay(double amount);
}

Extended abstract role

public class OnlinePayment extends Payment{
    public OnlinePayment(PaymentImplementor implementor) {
        super(implementor);
    }
    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void pay(double amount) {
        System.out.println("开始在线支付...");
        implementor.processPayment(amount);
        System.out.println("在线支付完成...");
    }
}

Test

public class Demo {
    public static void main(String[] args) {
        // 支付宝支付
        PaymentImplementor paymentImplementor = new AliPaymentImplementor();
        Payment payment = new OnlinePayment(paymentImplementor);
        payment.pay(100);
        System.out.println();
        // 微信支付
        paymentImplementor = new WechatPaymentImplementor();
        payment = new OnlinePayment(paymentImplementor);
        payment.pay(101);
        System.out.println();
        // 银联支付
        paymentImplementor = new UnionpayPaymentImplementor();
        payment = new OnlinePayment(paymentImplementor);
        payment.pay(102);
    }
}

This code is a simple example of implementing the bridge pattern. Among them, Payment is an abstract class, OnlinePayment is its subclass, PaymentImplementor is the interface, AliPaymentImplementor, UnionpayPaymentImplementor and WechatPaymentImplementor are all its implementation classes. In this way, the Payment class PayImplementor interface is decoupled and can be developed and extended independently.

In this example , the Payment class is abstract and cannot be instantiated, but is instantiated through the OnlinePayment subclass. The OnlinePayment subclass overrides the pay method and calls the implementor.processPayment method, which is derived from the class that implements the PaymentImplementor interface. Ah, for example, AliPaymentImplementor, UnionpayPaymentImplementor and WechatPaymentImplementor. This method allows the implementation class of the PaymentImplementor interface to be dynamically injected into the OnlinePayment class, thus realizing different payment methods without modifying the OnlinePayment class.

Summary

Advantages

• Separate the abstract and implementation parts so that they can change independently, thereby increasing the flexibility and scalability of the system.

• Managing the relationship between objects through abstract interfaces is more in line with the principles of object-oriented programming, making the system easier to maintain and understand.

• The bridge pattern can avoid the use of inheritance The class explosion problem is caused because it seems to use a combination relationship.

Disadvantages

• The bridge mode increases the complexity of the system and requires additional The abstraction layer may cause the system design to become complicated.

• If the bridge interface and implementation class are not designed appropriately, the coupling of the system may increase.

Application Scenario

• When a class has multiple changing dimensions (for example, a shape class has different colors and sizes), you can use the bridge pattern to Separate them to make the system more flexible.

• When you need to support different platforms, databases or protocols, you can use the bridge pattern to encapsulate these implementation details, making the client and implementation Parts can change independently without affecting each other.

• When you need to dynamically switch implementations at runtime, you can use the bridge mode to achieve this switching.

The above is the detailed content of How to use the Java bridge design pattern to elegantly separate abstraction from implementation. For more information, please follow other related articles on the PHP Chinese website!