Java设计模式之——适配器

原创 2011年05月20日 21:43:00

适配器:基于现有类所提供的服务,向客户提供接口,以满足客户的期望 

适配器是英语Adapter/adaptor的汉语翻译。适配器就是一个接口转换器.

                                                        《Java设计模式》 

类适配器 
客户的开发人员定义了一个接口,期望用这个接口来完成整数的求和操作,接口定义如下: 

Java代码 

1. public interface Operation{   

2.       public int add(int a,int b);   

3. }  

public interface Operation{

      public int add(int a,int b);

}


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

Java代码 

1. public class OtherOperation{   

2.       public int otherAdd(int a,int b){   

3.            return a + b;   

4.       }   

5. }  

public class OtherOperation{

      public int otherAdd(int a,int b){

           return a + b;

      }

}


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

Java代码 

1. public class AdapterOperation extends OtherOperation implements Operation{   

2.       public int add(int a,int b){   

3.            return otherAdd(a,b);   

4.       }   

5. }  

public class AdapterOperation extends OtherOperation implements Operation{

      public int add(int a,int b){

           return otherAdd(a,b);

      }

}


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

对象适配器 
我们再来看看另一种情况: 
假如客户接口期望的功能不止一个,而是多个: 

Java代码 

1. public interface Operation{   

2.       public int add(int a,int b);   

3.       public int minus(int a,int b);   

4.       public int multiplied(int a,int b);   

5. }  

public interface Operation{

      public int add(int a,int b);

      public int minus(int a,int b);

      public int multiplied(int a,int b);

}


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

Java代码 

1. public class OtherAdd{   

2.       public int otherAdd(int a,int b){   

3.            return a + b;   

4.       }   

5. }   

6.   

7. public class OtherMinus{   

8.       public int minus(int a,int b){   

9.            return a - b;   

10.       }   

11. }   

12.   

13. public class OtherMultiplied{   

14.       public int multiplied(int a,int b){   

15.            return a * b;   

16.       }   

17. }  

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是不能实现多继承的,所以我们不能通过构建一个适配器,让他来继承所有原以完成我们的期望,这时候怎么办呢?只能用适配器的另一种实现--对象适配器: 

Java代码 

1. public class AdapterOperation implements Operation{   

2.       private OtherAdd add;   

3.       private OtherMinus minus;   

4.       private OtherMultiplied multiplied;   

5.   

6.       public void setAdd(OtherAdd add){   

7.             this.add = add;   

8.       }   

9.   

10.       public void setMinus(OtherMinus minus){   

11.             this.minus = minus;   

12.       }   

13.   

14.       public void setMultiplied(OtherMultiplied multiplied){   

15.             this.multiplied = multiplied;   

16.       }   

17.   

18.       //适配加法运算   

19.       public int add(int a,int b){   

20.            return add.otherAdd(a,b);   

21.       }   

22.   

23.       //适配减法运算   

24.       public int minus(int a,int b){   

25.           return minus.minus(a,b);   

26.       }   

27.   

28.       //适配乘法运算   

29.       public int multiplied(int a,int b){   

30.          return multiplied.multiplied(a,b);   

31.       }   

32. }  

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代码 

1. public class A{   

2.    public int add(int a,int b){   

3.       return a + b;   

4.    }   

5. }  

public class A{

   public int add(int a,int b){

      return a + b;

   }

}


现在客户要一个新类B,要求能在保留类A功能的情况下增加一个运算减法的功能,并要求B能随时替换掉A但不能对已有系统造成影响。这样我们只能新建一个类B,并让B继承A。 

Java代码 

1. public class B extends A{   

2.     b(){   

3.       super();   

4.     }   

5.   

6.     public int minus(int a,int b){   

7.            //待实现的减法运算函数..   

8.     }   

9. }  

public class B extends A{

    b(){

      super();

    }

 

    public int minus(int a,int b){

           //待实现的减法运算函数..

    }

}


这时候,我们发现类C已经提供了实现减法的函数, 

Java代码 

1. public class C{   

2.     public int minus(int a,int b){   

3.            return a - b;   

4.     }   

5. }  

public class C{

    public int minus(int a,int b){

           return a - b;

    }

}


为了避免重复去设计该函数,我们决定引入C类,通过适配C类来达到我们的期望,但问题是A和C都是一个具体类,我们无法让B同时继承这个两个类,而B继承A又是必须的,所以我们只能考虑把C给内聚到B内部,对象适配器又得派上用场了。 

Java代码 

1. public class B extends A{   

2.   

3.  private C c;   

4.   

5.     B(){   

6.       super();   

7.     }   

8.   

9.     public void setMinus(C c){   

10.          this.c= c;   

11.     }   

12.   

13.     public int minus(int a,int b){   

14.            return c.minus(a,b);   

15.     }   

16. }  

public class B extends A{

 

    private C c;

 

    B(){

      super();

    }

 

    public void setMinus(C c){

         this.c= c;

    }

 

    public int minus(int a,int b){

           return c.minus(a,b);

    }

}


这样,在需要A类的地方都能用B类来代替,同时又保证了新的功能的引入。 

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

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

Java代码 

1. public interface WindowListener extends EventListener{   

2.  public void windowActivated(WindowEvent e);   

3.  public void windowClosed(WindowEvent e);   

4.  public void windowClosing(WindowEvent e);   

5.  public void windowDeactivated(WindowEvent e);   

6.  public void windowDeiconified(WindowEvent e);   

7.  public void windowIconified(WindowEvent e);   

8.  public void windowOpened(WindowEvent e);   

9. }  

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类,这是一个抽象类, 

Java代码 

1. public abstract class WindowAdapter implements WindowListener{   

2.  public void windowActivated(WindowEvent e){}   

3.  public void windowClosed(WindowEvent e){}   

4.  public void windowClosing(WindowEvent e){}   

5.  public void windowDeactivated(WindowEvent e){}   

6.  public void windowDeiconified(WindowEvent e){}   

7.  public void windowIconified(WindowEvent e){}   

8.  public void windowOpened(WindowEvent e){}   

9. }  

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接口。

适配器模式与Java应用

适配器模式与Java应用​ 在设计模式中或者说在很多编程场景下经常会使用到适配器,有心或无意。顾名思义,适配器就是将一个类的接口适配(包装/转换)成客户(调用者)希望的另一个接口。适配模式又可以细...
  • jackshiny
  • jackshiny
  • 2016年10月06日 13:07
  • 2347

Java设计模式菜鸟系列(八)适配器模式建模与实现

适配器模式(Adapter):将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。 主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。 1...
  • JAVE_LOVER
  • JAVE_LOVER
  • 2014年10月05日 19:52
  • 2357

设计模式——适配器模式 Java源代码

适配器模式,《Head First Design Patterns》给的代码的例子是关于鸭子和火鸡,然而鸭子和火鸡离日常生活比较远。这次,我改编了实验楼网站上面的例子,关于插座和充电器。...
  • u013390476
  • u013390476
  • 2016年01月01日 16:02
  • 2346

java 设计模式-----适配器模式

现实中的问题 有一个插座,这个插座是三个口的,但是我们手上只有两个触角的插头,一种笨方法就是直接强行把两个触角掰弯,插进去(这种事情我就做过),还有一种方法就是找一个转换头来。 ...
  • yujin753
  • yujin753
  • 2015年05月31日 12:12
  • 1070

Java 设计模式 接口型模式 之 适配器Adapter模式 (二)

适配器模式的意图 : 使用不同接口的类所提供的服务为客户端提供其所希望的接口; -- 问题解决场景 : 在 类A 中实现了接口中的抽象方法, 客户端B 已经定义好了方法的调用, 但是调用的方法 ...
  • jdsjlzx
  • jdsjlzx
  • 2014年03月04日 14:05
  • 4688

JAVA设计模式初探之适配器模式

1. 概述   将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。 2. 解决的问题   即Adapter模式使得原本由于接口不...
  • jason0539
  • jason0539
  • 2014年03月29日 07:53
  • 45157

Java笔记007_监听器和适配器的区别

监听器和适配器:Java图形用户界面(GUI,Graphics User interface)设计的抽象窗口工具集(AWT,Abstract Window Toolkit)的两个重要概念,他们都在ja...
  • hbgCSDN
  • hbgCSDN
  • 2014年11月24日 08:54
  • 1614

java适配器模式(Adapter)-结构型

Java适配器模式及其在Java中的应用
  • sunxianghuang
  • sunxianghuang
  • 2016年07月03日 21:26
  • 550

SpringMvc中使用到的适配器模式

此处采用了适配器模式, 由于Controller的类型不同,有多重实现方式,那么调用方式就不是确定的,如果需要直接调用Controller方法,需要在代码中写成如下形式:  Java...
  • bu123dian
  • bu123dian
  • 2016年10月10日 16:21
  • 2131

Java 实现适配器(Adapter)模式

平时我们会经常碰到这样的情况,有了两个现成的类,它们之间没有什么联系,但是我们现在既想用其中一个类的方法,同时也想用另外一个类的方法。有一个解决方法是,修改它们各自的接口,但是这是我们最不愿意看到的。...
  • jjwwmlp456
  • jjwwmlp456
  • 2014年10月08日 15:21
  • 7923
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java设计模式之——适配器
举报原因:
原因补充:

(最多只允许输入30个字)