构造型设计模式-适配器模式

结构型设计模式--适配器模式

适配器模式(参考自http://www.iteye.com/topic/262370 )

适配器模式的的核心思想是 ：为原接口类实现一个默认的抽象类，在该抽象类中编写每一个方法的默认实现，当我们需要编写一个具体类时，只需要继承该抽象类，而不需要实现原有的接口，并且不需要实现原有接口的所有方法接口，只实现需要的函数即可。

适配就是由“原”到“目标”的适配，而当中链接两者的关系就是适配器。它负责把“原”过度到“目标”。

类适配器

客户的开发人员定义了一个接口，期望用这个接口来完成整数的求和操作，接口定义如下：

public interface Operation{  
	public int add(int a,int b);  
}

开发人员在了解这个接口的定义后，发现一个第三方类，里面有一个方法能实现他们期望的功能，其代码如下：

public class OtherOperation {

    public int otherAdd(int a, int b) {
        return a + b;
    }
}

以上第三方类OtherOperation 的方法public int otherAdd(int a,int b) 所提供的功能，完全能符合客户的期望，所以只需要想办法把OtherOperation 的otherAdd(int a,int b) 和客户的Operation 接口联系起来，让这个第三方类来为客户提供他们期望的服务就行了，这样就避免了开发人员再度去研究类似OtherOperation的otherAdd(int a,int b) 方法的实现（利用已有的轮子，避免重复发明），这方法之一，就是用适配器模式：

public class AdapterOperation extends OtherOperation implements Operation {

    public int add(int a, int b) {
        return otherAdd(a, b);
    }
}

    以上就是适配器的实现方法之一，类适配器，在以上实现中存在着三中角色分别是：
    1：适配目标角色：Operation。
    2：适配类（原）角色：OtherOperation。
    3：适配器角色：AdapterOperation。
    其中适配器角色是适配器模式的核心。
    适配器的主要工作就是通过封装现有的功能，使他满足需要的接口。

对象适配器

假如客户接口期望的功能不止一个，而是多个：

public interface Operation {

    public int add(int a, int b);

    public int minus(int a, int b);

    public int multiplied(int a, int b);
}

而能提供这些实现的原可能不止一个：

public class OtherAdd {

    public int otherAdd(int a, int b) {
        return a + b;
    }
}

public class OtherMinus {

    public int minus(int a, int b) {
        return a - b;
    }
}

public class OtherMultiplied {

    public int multiplied(int a, int b) {
        return a * b;
    }
}

由于java是不能实现多继承的，所以我们不能通过构建一个适配器，让他来继承所有原以完成我们的期望，这时候怎么办呢?只能用适配器的另一种实现--对象适配器：

public class AdapterOperation implements Operation {

    private OtherAdd add;

    private OtherMinus minus;

    private OtherMultiplied multiplied;

    public void setAdd(OtherAdd add) {
        this.add = add;
    }

    public void setMinus(OtherMinus minus) {
        this.minus = minus;
    }

    public void setMultiplied(OtherMultiplied multiplied) {
        this.multiplied = multiplied;
    }

    //适配加法运算  
    public int add(int a, int b) {
        return add.otherAdd(a, b);
    }

    //适配减法运算  
    public int minus(int a, int b) {
        return minus.minus(a, b);
    }

    //适配乘法运算  
    public int multiplied(int a, int b) {
        return multiplied.multiplied(a, b);
    }
}

上面代码很明显，适配器并不是通过继承来获取适配类（原）的功能的，而是通过适配类的对象来获取的，这就解决了java不能多继承所带来的不便了。这也是java提倡的编程思想之一，即尽量使用聚合不要使用继承。

更灵活的实现--隐藏目标接口的抽象适配器

做java 桌面应用的都知道WindowListener接口，

public interface WindowListener extends EventListener{  
 public void windowActivated(WindowEvent e)；  
 public void windowClosed(WindowEvent e)；  
 public void windowClosing(WindowEvent e)；  
 public void windowDeactivated(WindowEvent e)；  
 public void windowDeiconified(WindowEvent e)；  
 public void windowIconified(WindowEvent e)；  
 public void windowOpened(WindowEvent e)；  
}

要实现这个接口，我们就必须实现它所定义的所有方法，但是实际上，我们很少需要同时用到所有的方法，我们要的只是其中的两三个。为了不使我们实现多余的方法，
jdk WindowListener提供了一个WindowListener的默认实现类WindowAdapter类，这是一个抽象类，

public abstract class WindowAdapter implements WindowListener{  
 public void windowActivated(WindowEvent e){}  
 public void windowClosed(WindowEvent e){}  
 public void windowClosing(WindowEvent e){}  
 public void windowDeactivated(WindowEvent e){}  
 public void windowDeiconified(WindowEvent e){}  
 public void windowIconified(WindowEvent e){}  
 public void windowOpened(WindowEvent e){}  
}

WindowAdapter类对WindowListener接口的所有有方法都提供了空实现，有了WindowAdapter类，我们只需要去继承WindowAdapter，然后选择我们所关心的方法来实现就行了，这样就避免了直接去实现WindowListener接口。

温习一些概念：

     关联，组合，聚合：

     关联和聚合的区别主要在语义上，关联的两个对象之间一般是平等的，例如你是我的朋友。

     聚合则一般不是平等的，例如一个公司包含了很多员工，其实现上是差不多的。

     聚合和组合的区别则在语义和实现上都有差别，组合的两个对象之间其生命期有很大的关联，被组合的对象是在组合对象创建的同时或者创建之后创建，在组合对象销毁之前销毁。一般来说被组合对象不能脱离组合对象独立存在，而且也只能属于一个组合对象，例如一个文档的版本，必须依赖于文档的存在，也只能属于一个文档。聚合则不一样，被聚合的对象可以属于多个聚合对象，例如一个员工可能可以属于多个公司。

构造型设计模式-适配器模式

相关推荐