Design patterns
Modello di ponte

Implementazione del pattern bridge in java

Il pattern del bridge disaccoppia l'astrazione dall'implementazione in modo che entrambi possano variare in modo indipendente. È stato realizzato con la composizione piuttosto che con l'eredità.

Diagramma UML di Bridge da wikipedia:

Hai quattro componenti in questo modello.

Abstraction : definisce un'interfaccia

RefinedAbstraction astrazione: implementa l'astrazione:

Implementor : definisce un'interfaccia per l'implementazione

ConcreteImplementor : implementa l'interfaccia Implementor.

The crux of Bridge pattern : due gerarchie di classi ortogonali che utilizzano la composizione (e nessuna ereditarietà). La gerarchia di astrazione e la gerarchia di implementazione possono variare in modo indipendente. L'implementazione non fa mai riferimento all'astrazione. L'astrazione contiene l'interfaccia di implementazione come membro (attraverso la composizione). Questa composizione riduce un ulteriore livello di gerarchia dell'ereditarietà.

Caso di utilizzo di parole reali:

Abilitare diversi veicoli per avere entrambe le versioni del sistema di cambio manuale e automatico.

Codice di esempio:

/* 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();
    }
}

produzione:

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

Spiegazione:

1. Vehicle è un'astrazione.
2. Car e Truck sono due implementazioni concrete del Vehicle .
3. Vehicle definisce un metodo astratto: addGear() .
4. Gear è un'interfaccia implementatore
5. ManualGear e AutoGear sono due implementazioni di Gear
6. Vehicle contiene un'interfaccia implementor piuttosto che l'implementazione dell'interfaccia. Compositon of implementor interface è un punto cruciale di questo modello: consente all'astrazione e all'implementazione di variare in modo indipendente.
7. Car and Truck definisce l'implementazione (astrazione ridefinita) per l'astrazione: addGear() : contiene Gear - Manual o Auto

Utilizzare il / i case / i per il modello Bridge :

1. L'astrazione e l' implementazione possono cambiare indipendentemente l'una dall'altra e non sono vincolate al momento della compilazione
2. Mappa gerarchie ortogonali - Una per l' astrazione e una per l' implementazione .