Design patterns
Wzór mostu

Implementacja wzorca mostu w java

Wzór mostka oddziela abstrakcję od implementacji, dzięki czemu oba mogą się różnić niezależnie. Zostało to osiągnięte raczej dzięki kompozycji niż dziedziczeniu.

Schemat mostka UML z wikipedii:

W tym wzorze masz cztery elementy.

Abstraction : określa interfejs

RefinedAbstraction : Implementuje abstrakcję:

Implementor : Definiuje interfejs do implementacji

ConcreteImplementor : Implementuje interfejs implementatora.

The crux of Bridge pattern : dwie ortogonalne hierarchie klas wykorzystujące kompozycję (bez dziedziczenia). Hierarchia abstrakcji i hierarchia implementacji mogą się różnić niezależnie. Implementacja nigdy nie odnosi się do abstrakcji. Abstrakcja zawiera interfejs implementacji jako element członkowski (poprzez kompozycję). Ta kompozycja zmniejsza jeszcze jeden poziom hierarchii dziedziczenia.

Prawdziwe słowo Przypadek użycia:

Włącz różne pojazdy w obu wersjach z manualnym i automatycznym systemem zmiany biegów.

Przykładowy kod:

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

wynik:

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

Wyjaśnienie:

1. Vehicle to abstrakcja.
2. Car i Truck to dwie konkretne implementacje Vehicle .
3. Vehicle definiuje metodę abstrakcyjną: addGear() .
4. Gear jest interfejsem implementatora
5. ManualGear i AutoGear to dwie implementacje Gear
6. Vehicle zawiera interfejs implementor zamiast implementacji interfejsu. Compositon interfejsu implementatora jest sedno tego wzorca: pozwala on na niezależną abstrakcję i implementację.
7. Car i Truck definiują implementację (przedefiniowanie abstrakcji) dla abstrakcji: addGear() : Zawiera Gear - albo Manual albo Auto

Przypadki użycia dla wzorca mostu :

1. Abstrakcja i implementacja mogą się zmieniać niezależnie od siebie i nie są powiązane w czasie kompilacji
2. Mapuj hierarchie ortogonalne - jedna dla abstrakcji i jedna dla implementacji .