Correct undestanding von Bridge-Muster

Question

Bin ich richtig undestand Brücke Muster:

VOR:

public class Main2 { 
      @SuppressWarnings("unused") 
      public static void main(String[] args) { 
       Car car11 = new BadNativeCar(); 
       Car car12 = new GoodNativeCar(); 
       Car car21 = new BadForeignCar(); 
       Car car22 = new GoodForeignCar(); 
      } 
     } 

     interface Car{ 
      public void drive(); 
      public void stop(); 
     } 

     class NativeCar implements Car{ 
      @Override 
      public void drive() { 
      } 
      @Override 
      public void stop() { 
      } 
     } 

     class ForeignCar implements Car{ 
      @Override 
      public void drive() { 
      } 
      @Override 
      public void stop() { 
      } 
     } 

     class GoodNativeCar extends NativeCar{ 
     } 
     class BadNativeCar extends NativeCar{ 
     } 
     class GoodForeignCar extends ForeignCar{ 
     } 
     class BadForeignCar extends ForeignCar{ 
     } 

AFTER (BRIDGE):

public class Main2 { 
     public static void main(String[] args) { 
      BadCar badCar = new BadCar(); 
      GoodCar goodCar = new GoodCar(); 
      CarAbstraction car11 = new NativeCar(badCar); 
      CarAbstraction car12 = new NativeCar(goodCar); 
      CarAbstraction car21 = new ForeignCar(badCar); 
      CarAbstraction car22 = new ForeignCar(goodCar); 
     } 
    } 

    interface CarAbstraction{ 
     public void drive(); 
     public void stop(); 
    } 

    //Abstraction 
    abstract class CarAbstractionImpl implements CarAbstraction{ 
     private CarImplementor carImplementor; 

     public CarAbstractionImpl(CarImplementor carImplementor) { 
      this.carImplementor = carImplementor; 
     } 

     @Override 
     public void drive() { 
      carImplementor.drive(); 
     } 
     @Override 
     public void stop() { 
      carImplementor.stop(); 
     } 
    } 

    //RefinedAbstraction1 
    class NativeCar extends CarAbstractionImpl{ 
     public NativeCar(CarImplementor carImplementor) { 
      super(carImplementor); 
     } 
    } 
    //RefinedAbstraction2 
    class ForeignCar extends CarAbstractionImpl{ 
     public ForeignCar(CarImplementor carImplementor) { 
      super(carImplementor); 
     } 
    } 



    //Implementor 
    interface CarImplementor extends CarAbstraction{ 
    } 

    //ConcreteImplementor1 
    class GoodCar implements CarImplementor{ 
     @Override 
     public void drive() { 
     } 
     @Override 
     public void stop() { 
     } 
    } 

    //ConcreteImplementor2 
    class BadCar implements CarImplementor{ 
     @Override 
     public void drive() { 
     } 
     @Override 
     public void stop() { 
     } 
    } 

Answer 1

Wie ich verstehe Sie versuchen, etwas tun wie:

When: 

     A 
    / \ 
    Aa  Ab 
/\ /\ 
Aa1 Aa2 Ab1 Ab2 

Refactor to: 

    A   N 
/ \ /\ 
Aa(N) Ab(N) 1 2 

(Got von hier: When do you use the Bridge Pattern? How is it different from Adapter pattern?)

bin ich mit Brücke Mustern nicht ganz in der Nähe vertraut, aber es sieht recht.

Answer 2

Aus Ihrer Frage, ich habe folgende Klassendiagramm:

VOR:

    ________Car_________ 
        /     \ 
       NativeCar    ForeignCar 
      /  \   /  \ 
    GoodNativeCar BadNativeCar GoodForeignCar BadForeignCar 

NACH:

  CarAbstraction 
       | 
     CarAbstractionImpl-------------HAS-A-------> CarImplementor 
     /   \       /  \ 
    NativeCar  ForeignCar     GoodCar  BadCar 

Wenn wir uns das Klassendiagramm des Brückenmuster bei http://www.oodesign.com/bridge-pattern.html, scheint es wie Brückenmuster. Die Klassenhierarchie CarAbstraction - CarAbstractionImpl kann jedoch weggelassen werden. Bedeutet CarAbstraction HAT Ein CarImplementor und NativeCar & ForeignCar wird von CarAbstraction übernommen.

So aus dem Klassendiagramm sieht es wie Brückenmuster.

Aber was ist mit konzeptionellen Punkten? Sind NativeCar und ForeignCar Abstraktion oder können sie auch als Implementierung verwendet werden? Sind sie mit GoodCar und BadCar austauschbar? Diese Tatsache muss ebenfalls berücksichtigt werden. Wenn NativeCar und ForeignCar Abstraktion sind und sie GoodCar und BadCar als Implementierung verwenden, dann ist dies ein Brückenmuster für diese Situation.