设计模式08-桥接模式

1. 概念

       将抽象部分和它的实现分离，使他们都可以独立变化  

      个人理解：将接口（或者抽象类）对象作为业务对象中的成员变量达到“多维度的变化”  ，这里说的多维度变化指的就是一个接口或者抽象类的具体实现是有多个  

例如： 

interface A{
    //method
}


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

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


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

     

2. 具体案例: 

  

/**********************************************************************
 * <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();
      }
}