undestanding corretto del Ponte del modello

Question

sono io correttamente undestand Ponte Pattern:

PRIMA:

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{ 
     } 

DOPO (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

quanto ho capito si tenta di fare qualcosa come:

When: 

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

Refactor to: 

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

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

Io non sono molto vicino familiarità con Ponte modello ma sembra giusto.

Answer 2

Dalla tua domanda, mi sono seguente diagramma di classi:

PRIMA:

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

DOPO:

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

Se guardiamo il diagramma delle classi del modello di ponte http://www.oodesign.com/bridge-pattern.html, sembra uno schema a ponte. Tuttavia, la gerarchia delle classi CarAbstraction - CarAbstractionImpl può essere omessa. Significa CarAbstraction HAS A CarImplementor e NativeCar & ForeignCar sarà ereditato da CarAbstraction.

Quindi, dal diagramma delle classi, sembra un modello di ponte.

Ma per quanto riguarda i punti concettuali? Sono astrazioni NativeCar e ForeignCar o possono essere utilizzate anche come implementazione? Sono scambiabili con GoodCar e BadCar? Anche questo fatto ha bisogno di considerazione. Se NativeCar e ForeignCar sono astrazione e GoodCar e BadCar come implementazione, allora questo modello di bridge per questa situazione.