Design patterns
Modèle de pont

Implémentation d'un modèle de pont en Java

Le modèle de pont sépare l'abstraction de la mise en œuvre pour que les deux puissent varier indépendamment. Cela a été réalisé avec la composition plutôt que l'héritage.

Diagramme UML Bridge de Wikipédia:

Vous avez quatre composants dans ce modèle.

Abstraction : définit une interface

RefinedAbstraction : implémente l'abstraction:

Implementor : définit une interface pour la mise en œuvre

ConcreteImplementor : Il implémente l'interface Implementor.

The crux of Bridge pattern : Deux hiérarchies de classes orthogonales utilisant la composition (et pas d'héritage). La hiérarchie d'abstraction et la hiérarchie d'implémentation peuvent varier de manière indépendante. La mise en œuvre ne fait jamais référence à l'abstraction. Abstraction contient une interface d'implémentation en tant que membre (via composition). Cette composition réduit encore un niveau de hiérarchie d'héritage.

Mot réel Cas d'utilisation:

Permettre à différents véhicules d’avoir les deux versions du système de vitesse manuel et automatique.

Exemple de code:

/* Implementor interface*/
interface Gear{
    void handleGear();
}

/* Concrete Implementor - 1 */
class ManualGear implements Gear{
    public void handleGear(){
        System.out.println("Manual gear");
    }
}
/* Concrete Implementor - 2 */
class AutoGear implements Gear{
    public void handleGear(){
        System.out.println("Auto gear");
    }
}
/* Abstraction (abstract class) */
abstract class Vehicle {
    Gear gear;
    public Vehicle(Gear gear){
        this.gear = gear;
    }
    abstract void addGear();
}
/* RefinedAbstraction - 1*/
class Car extends Vehicle{
    public Car(Gear gear){
        super(gear);
        // initialize various other Car components to make the car
    }
    public void addGear(){
        System.out.print("Car handles ");
        gear.handleGear();
    }
}
/* RefinedAbstraction - 2 */
class Truck extends Vehicle{
    public Truck(Gear gear){
        super(gear);
        // initialize various other Truck components to make the car
    }
    public void addGear(){
        System.out.print("Truck handles " );
        gear.handleGear();
    }
}
/* Client program */
public class BridgeDemo {    
    public static void main(String args[]){
        Gear gear = new ManualGear();
        Vehicle vehicle = new Car(gear);
        vehicle.addGear();
        
        gear = new AutoGear();
        vehicle = new Car(gear);
        vehicle.addGear();
        
        gear = new ManualGear();
        vehicle = new Truck(gear);
        vehicle.addGear();
        
        gear = new AutoGear();
        vehicle = new Truck(gear);
        vehicle.addGear();
    }
}

sortie:

Car handles Manual gear
Car handles Auto gear
Truck handles Manual gear
Truck handles Auto gear

Explication:

1. Vehicle est une abstraction.
2. Car and Truck sont deux applications concrètes du Vehicle .
3. Vehicle définit une méthode abstraite: addGear() .
4. Gear est une interface de mise en œuvre
5. ManualGear et AutoGear sont deux implémentations de Gear
6. Vehicle contient une interface de mise en implementor plutôt que d'implémenter l'interface. Compositon de l'interface de l'implémenteur est le noeud de ce modèle: il permet à l'abstraction et à l'implémentation de varier indépendamment.
7. Car and Truck definit l'implémentation (abstraction redéfinie) pour abstraction: addGear() : Contient Gear - Manual ou Auto

Cas d'utilisation du pattern Bridge :

1. L'abstraction et l' implémentation peuvent changer d'indépendance les unes des autres et elles ne sont pas liées au moment de la compilation
2. Mappez les hiérarchies orthogonales: une pour l' abstraction et une pour l' implémentation .