Design patterns
Brug patroon

Brugpatroonimplementatie in Java

Brugpatroon ontkoppelt abstractie van implementatie zodat beide onafhankelijk kunnen variëren. Het is bereikt met compositie in plaats van overerving.

Bridge UML-diagram van wikipedia:

Je hebt vier componenten in dit patroon.

Abstraction : het definieert een interface

RefinedAbstraction : het implementeert abstractie:

Implementor : het definieert een interface voor implementatie

ConcreteImplementor : het implementeert de implementatie-interface.

The crux of Bridge pattern : twee orthogonale klassenhiërarchieën die compositie gebruiken (en geen erfenis). De abstractiehiërarchie en de implementatiehiërarchie kunnen onafhankelijk variëren. Implementatie verwijst nooit naar abstractie. Abstractie bevat implementatie-interface als lid (via samenstelling). Deze samenstelling vermindert nog een niveau van overervingshiërarchie.

Echte woord gebruik case:

Schakel verschillende voertuigen in om beide versies van handmatig en automatisch versnellingssysteem te hebben.

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

output:

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

Uitleg:

1. Vehicle is een abstractie.
2. Car en Truck zijn twee concrete implementaties van Vehicle .
3. Vehicle definieert een abstracte methode: addGear() .
4. Gear is de interface van de implementeerder
5. ManualGear en AutoGear zijn twee implementaties van Gear
6. Vehicle bevat implementor interface in plaats van implementatie van de interface. Compositon of implementor interface is de kern van dit patroon: het laat abstractie en implementatie onafhankelijk variëren.
7. Car en Truck definiëren implementatie (opnieuw gedefinieerde abstractie) voor abstractie: addGear() : het bevat Gear - Manual of Auto

Gebruik case (s) voor brugpatroon :

1. Abstractie en implementatie kunnen onafhankelijk van elkaar veranderen en ze zijn niet gebonden tijdens het compileren
2. Breng orthogonale hiërarchieën in kaart - een voor abstractie en een voor implementatie .