设计模式08-桥接模式

interface A{
    //method
}


class Business{
    private A  a  ;  //将接口作为成员变量

    public Business(A a){
        this.a = a ; 
   }
}


class  A1 implements A{}
class  A2 implements A{}

/**********************************************************************
 * <pre>
 * FILE : Demo02.java
 * CLASS : Demo02
 *
 * AUTHOR : Liaokailin
 *
 * FUNCTION : TODO
 *
 *
 *======================================================================
 * CHANGE HISTORY LOG
 *----------------------------------------------------------------------
 * MOD. NO.|   DATE   |   NAME  | REASON  | CHANGE REQ.
 *----------------------------------------------------------------------
 *             |2014-3-5|Liaokailin| Created |
 * DESCRIPTION:
 * </pre>
 ***********************************************************************/
package org.demo.brige.demo02;
/**
 * think in patterns 中的例子
 * 桥接模式： 将抽象部分和它的实现分离，使他们都可以独立变化
 * 
 * JDK中的JDBC就是桥接模式的经典例子。oracle、mysql、mssqlserver等数据库都有自己的驱动来实现JDBC的接口。如果要修改数据库，只需要修改一下驱动类、URL、用户名、密码，就可以了，其他的增删改查的代码，不需要变。
桥接模式和适配器模式很像，它们有什么区别吗？
桥接模式：先规定接口，再让客户去实现这些接口。比如规定java.sql.Connection，oracle就必须实现java.sql.Connection这个接口。
适配器模式：已经定义了接口，但是和客户要的接口不一致，于是新增接口，用新接口去调用旧的接口。为什么不直接把旧接口改为新接口？因为要保持兼容性啊。比如原来的方法叫method1，现在改为method2，但是其他调用的地方，还是method1，于是就会报找不到method1这个方法。
 * Function : 
 * @author : Liaokailin
 * CreateDate : 2014-3-5
 * version : 1.0
 */
public class Demo02 {
    public static void main(String[] args){
        Implementation impl = new Implementation1() ;
        ClientService1 cs = new ClientService1(impl) ;
        cs.service1() ;
        //cs.serviceA() ;
    }
}


//实现 ： 属于后端业务代码 对前段不可见

interface  Implementation {
    void facility1() ; //设备1
    void facility2() ; //设备2
    void facility3() ; //设备3
    void facility4() ; //设备4
    
}


//抽象: 提供给客户端调用的接口 其实现通过Implementation的子类体现 （ 通过成员变量实现两者之间的关联 不通过extends 或者 implements） 

class Abstraction{
    private Implementation implementation ;  //作为成员变量
    public Abstraction(Implementation implementation){
        this.implementation = implementation ;
    }
    
    public void service1(){
        implementation.facility1() ;
        implementation.facility2() ;
    }
    
    public void service2(){
        implementation.facility2() ;
        implementation.facility3() ;
    }
    
    public void service3(){
        implementation.facility1() ;
        implementation.facility2() ;
        implementation.facility4() ;
    }
    // For use by subclasses
    protected Implementation getImplementation(){
        return this.implementation ;
    }
    
}


class ClientService1 extends Abstraction{

    public ClientService1(Implementation implementation) {
        super(implementation);
    }
    
    public void serviceA(){
        service1() ;
        service2() ;
     }
    public void serviceB() {
        service3();
     }
}



class ClientService2 extends Abstraction{
    public ClientService2(Implementation implementation) {
        super(implementation);
    }
    public void serviceC(){
        service2() ;
        service3() ;
     }
    public void serviceD() {
        service1();
        service3();
     }
    
     public void serviceE() {
            getImplementation().facility3();
     }
}

/**
 * 后端的实现不通过其子类实现 而是委派给更深层次的lib库 
 * 下面模拟一个lib库 提供若干方法
 */
class Library1{
    public void method1(){
        System.out.println("lib1:method1") ;
    }
    
    public void method2(){
        System.out.println("lib1: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{
    private Library1 delegate = new Library1() ;
    @Override
    public void facility1() {
        System.out.println("Implementation1:facility1") ;
        delegate.method1() ;
    }

    @Override
    public void facility2() {
        System.out.println("Implementation1:facility2") ;
        delegate.method2() ;
    }

    @Override
    public void facility3() {
        System.out.println("Implementation1:facility3") ;
        delegate.method2() ;
        delegate.method1() ;
    }

    @Override
    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();
      }
}