Design patterns
Bridge mönster

Bromönsterimplementering i java

Bridge-mönstret avkopplar abstraktion från implementeringen så att båda kan variera oberoende. Det har uppnåtts med komposition snarare än arv.

Bridge UML-diagram från wikipedia:

Du har fyra komponenter i detta mönster.

Abstraction : Det definierar ett gränssnitt

RefinedAbstraction : Det implementerar abstraktion:

Implementor : Den definierar ett gränssnitt för implementering

ConcreteImplementor : Det implementerar implementeringsgränssnittet.

The crux of Bridge pattern : Två ortogonala klasshierarkier med komposition (och inget arv). Abstraktionshierarkin och implementeringshierarkin kan variera oberoende av varandra. Genomförandet hänvisar aldrig till abstraktion. Abstraktion innehåller implementeringsgränssnitt som medlem (genom sammansättning). Denna sammansättning minskar ytterligare en nivå av arvhierarki.

Verkligt ord Använd fall:

Gör det möjligt för olika fordon att ha både versioner av manuellt och automatisk växelsystem.

Exempelkod:

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

produktion:

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

Förklaring:

1. Vehicle är en abstraktion.
2. Car and Truck är två konkreta implementationer av Vehicle .
3. Vehicle definierar en abstrakt metod: addGear() .
4. Gear är implementatorgränssnitt
5. ManualGear och AutoGear är två implementeringar av Gear
6. Vehicle innehåller implementor gränssnitt snarare än att implementera gränssnittet. Compositon för implementatorgränssnittet är kärnan i detta mönster: Det gör att abstraktion och implementering kan variera oberoende.
7. Car and Truck definierar implementering (omdefinierad abstraktion) för abstraktion: addGear() : Den innehåller Gear - antingen Manual eller Auto

Använd fall (er) för Bridge-mönster :

1. Abstraktion och implementering kan förändra oberoende varandra och de är inte bundna vid sammanställningstillfället
2. Kartlägga ortogonala hierarkier - En för abstraktion och en för implementering .