橋模式的正確undestanding

Question

我是正確的已瞭解Bridge模式：

BEFORE：

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

當我明白你想做類似的事情：

When: 

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

Refactor to: 

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

（GOT從這裏：When do you use the Bridge Pattern? How is it different from Adapter pattern?）

我不是很密​​切熟悉橋模式，但它看起來正確。

Answer 2

從你的問題，我得到了下面的類圖：

BEFORE：

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

AFTER：

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

如果我們看一下橋模式的類圖http://www.oodesign.com/bridge-pattern.html，它似乎是橋樑模式。但是，類層次結構CarAbstraction - CarAbstractionImpl可以忽略。意味着CarAbstraction具有CarImplementor和NativeCar &外國汽車將由CarAbstraction繼承。

因此，從類圖看，它看起來像橋樑模式。

但是概念要點呢？ NativeCar和ForeignCar是抽象還是可以用作實現？它們是否可以與GoodCar和BadCar交換？這個事實也需要考慮。如果NativeCar和ForeignCar是抽象的並且它們是GoodCar和BadCar作爲實現，那麼這種橋接模式適用於這種情況。