Introduction détaillée au mode pontage Java

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement les problèmes liés au mode pont. Le mode pont sépare l'abstraction et l'implémentation afin qu'elles puissent changer indépendamment, réduisant ainsi les deux problèmes possibles d'abstraction et d'implémentation. regardez le degré de couplage des dimensions variables, j'espère que cela sera utile à tout le monde.

Apprentissage recommandé : "Tutoriel vidéo Java"

En fait, dans la vraie vie, il existe de nombreuses catégories qui peuvent avoir deux dimensions ou plus. Par exemple, les graphiques peuvent être divisés par forme et par couleur, si. L'héritage est utilisé, il y aura m*n types de graphiques avec m formes et n couleurs. Non seulement il y aura de nombreuses sous-classes correspondantes, mais il sera également difficile de les développer.

Par exemple, du texte de différentes couleurs et polices, des voitures de différentes marques et puissances, des hommes et des femmes de différents genres et professions, des lecteurs multimédias prenant en charge différentes plates-formes et différents formats de fichiers, etc. Ces problèmes peuvent être bien résolus si vous utilisez le mode pont.

---

1. La définition du modèle de pont

sépare l'abstraction et la mise en œuvre afin qu'elles puissent changer indépendamment. Il est implémenté en utilisant une relation de combinaison au lieu d'une relation d'héritage, réduisant ainsi le degré de couplage des deux dimensions variables d'abstraction et de mise en œuvre. Type de modèle : Modèle de conception structurelle : Diagramme de classes principal :

Figure. description :

Classe client :
L'appelant du mode pont

Classe abstraite (Abstraction) :

Maintient Implementor/c'est-à-dire sa classe d'implémentation ConcretelmplementorA... Les deux sont dans une relation combinée, et l'Abstraction agit comme pont
1. RehinedAbstraction :
est une sous-classe de la classe abstraite d'abstraction lmplementor : interface de la classe d'implémentation du comportement
2. ConcretelmplementorA/B :
classe d'implémentation concrète du comportement
3. À partir du diagramme UML :
La classe abstraite et l'interface ici sont une relation d'agrégation , En fait, la relation entre appeler et être appelé
2 Avantages et inconvénients du mode pont
5. Avantages :

---

Séparation de l'abstraction et de la mise en œuvre, forte évolutivité

Conforme au principe. d'ouverture et de fermetureConforme au principe de synthèse et de réutilisation

Ses détails de mise en œuvre sont transparents pour les clients
2. Inconvénients :

La relation d'agrégation étant établie au niveau de la couche d'abstraction, les développeurs sont tenus de concevoir et un programme d'abstraction et être capable d'identifier correctement deux dimensions changeantes indépendamment dans le système. Cela augmente la difficulté de compréhension et de conception du système

3. La structure du mode pont
• Le mode pont comprend les éléments principaux suivants. rôles :

---

Rôle d'abstraction (abstraction) :

Définir des classes abstraites et inclure une référence à l'objet implémenté

Rôle d'abstraction étendue (abstraction raffinée)

 : c'est une sous-classe du rôle abstrait, implémente les méthodes métier dans la classe parent et appelle les méthodes métier dans le rôle implémenté via la relation de combinaison
1. Rôle d'implémenteur : définit l'interface du rôle implémenté, qui peut être appelée par le rôle abstrait étendu. Rôle d'implémenteur concret : fournit l'implémentation spécifique du rôle implémenté. Interface de rôle implémentée. Diagramme de structure :
Le code d'implémentation de ce diagramme de structure :
4. Rôle de réalisation :

/**
 * 实视化角色
 */public interface Implemntor {

    public void OperationImpl();}

Rôle d'implémentation concrète :

/**
 * 具体实现化角色
 */public class ConcreteImplementorA implements Implemntor{
    @Override
    public void OperationImpl() {
        System.out.println("具体实现化角色被访问");
    }}

Rôle abstrait :

/**
 * 抽象化角色
 */public abstract class Abstraction {

    protected Implemntor implemntor;

    protected Abstraction(Implemntor implemntor){
        this.implemntor = implemntor;
    }

    public abstract void Operation();}

Rôle abstrait étendu :

/**
 * 扩展抽象化角色
 */public class RefinedAbstraction extends Abstraction{

    protected RefinedAbstraction(Implemntor implemntor) {
        super(implemntor);
    }

    public void Operation(){
        System.out.println("扩展抽象化角色被访问");
        implemntor.OperationImpl();
    }}

Classe de test :

public class Test {
    public static void main(String[] args) {

        Implemntor implemntor = new ConcreteImplementorA();
        Abstraction abs = new RefinedAbstraction(implemntor);
        abs.Operation();

    }}

Sortie :

扩展抽象化角色被访问
具体实现化角色被访问

4. Implémentation de cas du mode pont

Placez l'implémentation et l'abstraction dans deux niveaux de classe différents afin que les deux niveaux puissent être changé indépendamment

Le transport roule sur la route. Il y a deux dimensions de changement ici

Les types de transport sont différents

Les routes sont également divisées en routes en ciment et en routes asphaltées.

---

Classe de transport :

/**
 * 交通工具类
 */public interface Vehicle {

    public void drive();}

Moyen de transport spécifique : voiture

/**
 * 具体的交通工具：小汽车
 */public class Car implements Vehicle{
    @Override
    public void drive() {
        System.out.println("小汽车");
    }}

Moyen de transport spécifique : bus

/**
 * 具体的交通工具:大巴车
 */public class Bus implements Vehicle{
    @Override
    public void drive() {
        System.out.println("大巴车");
    }}

Route abstraite :

/**
 * 抽象的路
 */public abstract class Road {

    protected Vehicle vehicle;

    public Road(Vehicle vehicle){
        this.vehicle = vehicle;
    }

    public abstract void driveOnRoad();}

Con route de Crète : route asphaltée

/**
 * 具体的路：油柏路
 */public class UnpavedRoad extends Road{
    public UnpavedRoad(Vehicle vehicle) {
        super(vehicle);
    }

    @Override
    public void driveOnRoad() {

        super.vehicle.drive();
        System.out.println("行驶在油柏路");
    }}

Route spécifique : route cimentée

/**
 * 具体的路：水泥路
 */public class CementRoad extends Road{
    public CementRoad(Vehicle vehicle) {
        super(vehicle);
    }

    @Override
    public void driveOnRoad() {
        super.vehicle.drive();
        System.out.println("行驶在水泥路");
    }}

Classe de test :

//测试public class Test {
    public static void main(String[] args) {

        Road roadCar = new CementRoad(new Car());
        roadCar.driveOnRoad();

        Road roadBus = new CementRoad(new Bus());
        roadBus.driveOnRoad();

    }}

Sortie :

小汽车
行驶在水泥路
大巴车
行驶在水泥路

---

5、桥接模式的注意事项

1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，这有助于系统进行分层设计，从而产生更好的结构化系统
2. 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成
3. 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本
4. 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计和编程
5. 桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围有一定的局限性,即需要有这样的应用场景

---

6、桥接模式应用场景

对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用.

推荐学习：《java视频教程》

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!