//: adapter:SimpleAdapter.java

// "Object Adapter" from GoF diagram

package adapter;

import junit.framework.*;

 

class Target {

  public void request() {}

}

 

class Adaptee {

  public void specificRequest() {

    System.out.println("Adaptee: SpecificRequest");

  }

}

 

class Adapter extends Target {

  private Adaptee adaptee;

  public Adapter(Adaptee a) {

    adaptee = a;

  }

  public void request() {

    adaptee.specificRequest();

  }

}

 

public class SimpleAdapter extends TestCase  {

  Adaptee a = new Adaptee();

  Target t = new Adapter(a);

  public void test() {

    t.request();

  }

  public static void main(String args[]) {

    junit.textui.TestRunner.run(SimpleAdapter.class);

  }

} ///:~

 

//: adapter:AdapterVariations.java

// Variations on the Adapter pattern.

package adapter;

import junit.framework.*;

 

class WhatIHave {

  public void g() {}

  public void h() {}

}

 

interface WhatIWant {

  void f();

}

 

class SurrogateAdapter implements WhatIWant {

  WhatIHave whatIHave;

  public SurrogateAdapter(WhatIHave wih) {

    whatIHave = wih;

  }

  public void f() {

    // Implement behavior using

    // methods in WhatIHave:

    whatIHave.g();

    whatIHave.h();

  }

}

 

class WhatIUse {

  public void op(WhatIWant wiw) {

    wiw.f();

  }

}

 

// Approach 2: build adapter use into op():

class WhatIUse2 extends WhatIUse {

  public void op(WhatIHave wih) {

    new SurrogateAdapter(wih).f();

  }

}

 

// Approach 3: build adapter into WhatIHave:

class WhatIHave2 extends WhatIHave

implements WhatIWant {

  public void f() {

    g();

    h();

  }

}

 

// Approach 4: use an inner class:

class WhatIHave3 extends WhatIHave {

  private class InnerAdapter implements WhatIWant{

    public void f() {

      g();

      h();

    }

  }

  public WhatIWant whatIWant() {

    return new InnerAdapter();

  }

}

 

public class AdapterVariations extends TestCase  {

  WhatIUse whatIUse = new WhatIUse();

  WhatIHave whatIHave = new WhatIHave();

  WhatIWant adapt= new SurrogateAdapter(whatIHave);

  WhatIUse2 whatIUse2 = new WhatIUse2();

  WhatIHave2 whatIHave2 = new WhatIHave2();

  WhatIHave3 whatIHave3 = new WhatIHave3();

  public void test() {

    whatIUse.op(adapt);

    // Approach 2:

    whatIUse2.op(whatIHave);

    // Approach 3:

    whatIUse.op(whatIHave2);

    // Approach 4:

    whatIUse.op(whatIHave3.whatIWant());

  }

  public static void main(String args[]) {

    junit.textui.TestRunner.run(AdapterVariations.class);

  }

} ///:~

//: bridge:BridgeStructure.java

// A demonstration of the structure and operation

// of the Bridge Pattern.

package bridge;

import junit.framework.*;

 

class Abstraction {

  private Implementation implementation;

  public Abstraction(Implementation imp) {

    implementation = imp;

  }

  // Abstraction used by the various front-end

  // objects in order to implement their

  // different interfaces.

  public void service1() {

    // Implement this feature using some

    // combination of back-end implementation:

    implementation.facility1();

    implementation.facility2();

  }

  public void service2() {

    // Implement this feature using some other

    // combination of back-end implementation:

    implementation.facility2();

    implementation.facility3();

  }

  public void service3() {

    // Implement this feature using some other

    // combination of back-end implementation:

    implementation.facility1();

    implementation.facility2();

    implementation.facility4();

  }

  // For use by subclasses:

  protected Implementation getImplementation() {

    return implementation;

  }

}

 

class ClientService1 extends Abstraction {

  public ClientService1(Implementation imp) { super(imp); }

  public void serviceA() {

    service1();

    service2();

  }

  public void serviceB() {

    service3();

  }

}

 

class ClientService2 extends Abstraction {

  public ClientService2(Implementation imp) { super(imp); }

  public void serviceC() {

    service2();

    service3();

  }

  public void serviceD() {

    service1();

    service3();

  }

  public void serviceE() {

    getImplementation().facility3();

  }

}

 

interface Implementation {

  // The common implementation provided by the

  // back-end objects, each in their own way.

  void facility1();

  void facility2();

  void facility3();

  void facility4();

}

 

class Library1 {

  public void method1() {

    System.out.println("Library1.method1()");

  }

  public void method2() {

    System.out.println("Library1.method2()");

  }

}

 

class Library2 {

  public void operation1() {

    System.out.println("Library2.operation1()");

  }

  public void operation2() {

    System.out.println("Library2.operation2()");

  }

  public void operation3() {

    System.out.println("Library2.operation3()");

  }

}

 

class Implementation1 implements Implementation {

  // Each facility delegates to a different library

  // in order to fulfill the obligations.

  private Library1 delegate = new Library1();

  public void facility1() {

    System.out.println("Implementation1.facility1");

    delegate.method1();

  }

  public void facility2() {

    System.out.println("Implementation1.facility2");

    delegate.method2();

  }

  public void facility3() {

    System.out.println("Implementation1.facility3");

    delegate.method2();

    delegate.method1();

  }

  public void facility4() {

    System.out.println("Implementation1.facility4");

    delegate.method1();

  }

}

 

class Implementation2 implements Implementation {

  private Library2 delegate = new Library2();

  public void facility1() {

    System.out.println("Implementation2.facility1");

    delegate.operation1();

  }

  public void facility2() {

    System.out.println("Implementation2.facility2");

    delegate.operation2();

  }

  public void facility3() {

    System.out.println("Implementation2.facility3");

    delegate.operation3();

  }

  public void facility4() {

    System.out.println("Implementation2.facility4");

    delegate.operation1();

  }

}

 

public class BridgeStructure extends TestCase  {

  public void test1() {

    // Here, the implementation is determined by

    // the client at creation time:

    ClientService1 cs1 =

      new ClientService1(new Implementation1());

    cs1.serviceA();

    cs1.serviceB();

  }

  public void test2() {

    ClientService1 cs1 =

      new ClientService1(new Implementation2());

    cs1.serviceA();

    cs1.serviceB();

  }

  public void test3() {

    ClientService2 cs2 =

      new ClientService2(new Implementation1());

    cs2.serviceC();

    cs2.serviceD();

    cs2.serviceE();

  }

  public void test4() {

    ClientService2 cs2 =

      new ClientService2(new Implementation2());

    cs2.serviceC();

    cs2.serviceD();

    cs2.serviceE();

  }

  public static void main(String[] args) {

    junit.textui.TestRunner.run(BridgeStructure.class);

  } 

} ///:~