Comment utiliser le modèle de conception du pont Java pour séparer élégamment l'abstraction de l'implémentation

Introduction

Java Bridge Pattern (également appelé Bridge Pattern) est un modèle de conception qui sépare l'abstraction et l'implémentation afin qu'elles puissent changer indépendamment. Il est séparé par une grande classe ou une série de classes étroitement liées. Cette séparation est obtenue en la divisant en. deux hiérarchies indépendantes, dont l'une contient des classes ou interfaces abstraites et l'autre des classes d'implémentation. Le modèle de pont permet aux classes abstraites et aux classes d'implémentation de changer indépendamment, réalisant ainsi un couplage lâche.

En Java, le modèle de pont utilise généralement des interfaces pour définir la partie abstraite, utiliser des classes abstraites pour implémenter des implémentations partielles et les combiner via la composition. La partie abstraite contient une référence qui veut uniquement implémenter la partie, et la partie implémentation implémente l'interface définie dans la partie abstraite

Le Java. Le modèle de pont est divisé en quatre rôles suivants :

• Rôle d'abstraction (Abstraction) : définir l'interface abstraite et maintenir une référence à l'objet implémenté

• Extend abstraction Abstraction raffinée : étend le rôle abstrait, généralement une sous-classe. du rôle abstrait, pour implémenter les méthodes métier dans le rôle abstrait.

• Implementor : Définit l'interface qui implémente le rôle, cette interface Elle ne doit pas nécessairement être exactement la même que l'interface du rôle abstrait. , les deux interfaces peuvent être complètement différentes.

• Implémentateur concret : le rôle implémenté concrètement implémente l'interface du rôle implémenté et complète une logique métier spécifique.

implémentation

Par exemple, dans un site Web de commerce électronique, cela peut être nécessaire pour prendre en charge plusieurs méthodes de support, telles que Alipay, WeChat Pay et UnionPay Payment, etc. En utilisant le mode pont, vous pouvez facilement ajouter ou changer différentes méthodes de paiement, pour répondre aux besoins des utilisateurs.

Rôle de mise en œuvre

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

Mise en œuvre concrète 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 + "元...");
    }
}

Rôle abstrait

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

Rôle abstrait étendu

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("在线支付完成...");
    }
}

Testing

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);
    }
}

Ce code est un exemple d'implémentation simple du modèle de pont Parmi eux, Payment est une classe abstraite, OnlinePayment est sa sous-classe, PaymentImplementor est. l'interface, AliPaymentImplementor, UnionpayPaymentImplementor et WechatPaymentImplementor sont toutes ses classes d'implémentation. De cette façon, l'interface de la classe Payment PayImplementor est découplée et peut être développée indépendamment et en extension.

Dans cet exemple, la classe Payment est abstraite et ne peut pas être instanciée, mais est instancié via la sous-classe OnlinePayment.La sous-classe OnlinePayment remplace la méthode pay et appelle la méthode Implementor.processPayment, qui est Les classes qui implémentent l'interface PaymentImplementor viennent naturellement, par exemple, AliPaymentImplementor, UnionpayPaymentImplementor et WechatPaymentImplementor. l'interface PaymentImplementor à injecter dynamiquement dans la classe OnlinePayment, réalisant ainsi différentes méthodes de paiement sans modifier la classe OnlinePayment. flexibilité et évolutivité du système.

Gérer la relation entre les objets via des interfaces abstraites, il est plus conforme aux principes de la programmation orientée objet, ce qui rend le système plus facile à maintenir et à comprendre. Le modèle de pont peut éviter la classe. problème d'explosion causé par l'utilisation de l'héritage, car il semble utiliser une relation de combinaison. Les modèles augmentent la complexité du système et nécessitent des couches d'abstraction supplémentaires, ce qui peut compliquer la conception du système.

• Si vous pontez les interfaces. et les classes d'implémentation ne sont pas conçues de manière appropriée, le couplage du système peut augmenter.

• Scénarios d'application

• Lorsqu'une classe a plusieurs dimensions changeantes (par exemple, une classe de forme a différentes couleurs et tailles), le modèle de pont peut être utilisé pour les séparer, rendant le système plus flexible.

Lorsque vous avez besoin de prendre en charge différentes plates-formes, bases de données ou protocoles, vous pouvez utiliser le modèle de pont pour encapsuler ces détails d'implémentation, afin que le client et les parties d'implémentation puissent changer indépendamment sans s'affecter les uns les autres.

• Changez dynamiquement les implémentations lorsque vous devez exécuter, vous pouvez utiliser le mode pont pour réaliser cette commutation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!