Java23种设计模式--Adapter（适配器）

柔情只为你懂 2022-09-19 12:10 118阅读 0赞

**实例场景**：我们以前的电脑上键盘的usb接口有的是圆形的，现在假如这个接口坏了，用户想要更换一个，但市场上基本上是方形usb接口，很无赖，配不上号，这时，店主告诉用户不用担心，买一个转换器就行，转换器可以兼容圆形和方形接口，问题就解决了。这个场景用到了我们所说的：适配器模式

**Adapter模式的定义**：把一个类的接口变换成客户端所期待的另外一种接口，使得原本由于接口不兼容而不能再一起工作的那些类可以一起工作。

**适配器模式分类**：1.类的适配器模式（采用继承实现）2.对象适配器（采用对象组合方式实现,委派）

模式的构成：以问题中例子为模型

**目标抽象角色(Target):**定义客户所期待要使用的接口，我们把键盘当做客户端，客户端所需要使用的usb接口是圆形的，在这里就可以抽象出来一个圆形接口的设备（并不一定是键盘）。

**源角色(Adaptee)**:需要被适配的接口，在这里指的是方形usb接口键盘。

**适配器角色(Adapter)：**用来把源接口转换成符合要求的目标接口的设备，在这里指的是我们的那个“转换器”。

**客户端(Client)：**这里指的就是那个键盘。

**类适配器模式:**

**源代码:**

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  package cn.com.pattern;   
2.     
3.  //目标抽象角色，用户需要的是有圆形的usb接口   
4.  public interface Target \{   
5.      public void provideCircleUsb();   
6.  \}

package cn.com.pattern; 
     
    //目标抽象角色，用户需要的是有圆形的usb接口 
    public interface Target { 
        public void provideCircleUsb(); 
    }

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  package cn.com.pattern;   
2.  //源角色，这里是指提供方形的usb接口   
3.  public class Adaptee \{   
4.      public void provideSquareUsb()\{   
5.          System.out.println("我提供方形的USB接口");   
6.      \}   
7.  \}

package cn.com.pattern; 
    //源角色，这里是指提供方形的usb接口 
    public class Adaptee { 
        public void provideSquareUsb(){ 
            System.out.println("我提供方形的USB接口"); 
        } 
    }

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  package cn.com.pattern;   
2.  //适配角色，这里指老板买给我们的那个转换器   
3.  public class Adapter extends Adaptee implements Target\{   
4.      @Override   
5.      //转换器将方形的接口转换为圆形接口   
6.      public void provideCircleUsb() \{   
7.          this.provideSquareUsb();   
8.      \}   
9.  \}

package cn.com.pattern; 
    //适配角色，这里指老板买给我们的那个转换器 
    public class Adapter extends Adaptee implements Target{ 
        @Override 
        //转换器将方形的接口转换为圆形接口 
        public void provideCircleUsb() { 
            this.provideSquareUsb(); 
        } 
    }

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  package cn.com.pattern;   
2.     
3.  //客户端，也就是问题中的键盘   
4.  public class Client \{   
5.      public static void main(String\[\] args) \{   
6.          Target target=new Adapter();   
7.          //键盘只能使用圆形的USB接口   
8.          target.provideCircleUsb();   
9.      \}   
10. \}

package cn.com.pattern; 
     
    //客户端，也就是问题中的键盘 
    public class Client { 
        public static void main(String[] args) { 
            Target target=new Adapter(); 
            //键盘只能使用圆形的USB接口 
            target.provideCircleUsb(); 
        } 
    }

最后将会输出：

我提供方形的USB接口

达到了用户需要的效果，让只支持圆形USB接口的键盘使用方形USB接口

以上是类的适配器模式，对象的适配器模式的不同之处在于Adapter角色封装了Adaptee角色，而不像类的适配器模式所采取的继承方式。其原理基本上是相似的。

**对象适配器模式:(优先使用)**

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  public class Adapter implements Target\{   
2.         private Adaptee adptee；   
3.         public Adapter(Adaptee adptee)\{   
4.            this.adptee=adptee;   
5.            \}   
6.              
7.          @Override   
8.      //转换器将方形的接口转换为圆形接口   
9.      public void provideCircleUsb() \{   
10.         adptee.provideSquareUsb();   
11.     \}   
12. \}

public class Adapter implements Target{ 
           private Adaptee adptee； 
           public Adapter(Adaptee adptee){ 
              this.adptee=adptee; 
              } 
              
            @Override 
        //转换器将方形的接口转换为圆形接口 
        public void provideCircleUsb() { 
            adptee.provideSquareUsb(); 
        } 
    }

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  //客户端，也就是问题中的键盘   
2.  public class UClient \{  
3.       public static void main(String\[\] args) \{   
4.          Adaptee adaptee=new Adaptee();  
5.              Target target=new Adapter(adaptee);   
6.              //键盘只能使用圆形的USB接口   
7.              target.provideCircleUsb();   
8.          \}   
9.  \}

//客户端，也就是问题中的键盘 
    public class UClient {
    	 public static void main(String[] args) { 
    		Adaptee adaptee=new Adaptee();
    	        Target target=new Adapter(adaptee); 
    	        //键盘只能使用圆形的USB接口 
    	        target.provideCircleUsb(); 
    	    } 
    }

**类的适配器模式和对象适配器模式的比较：**

1.类的适配模式用于单一源的适配，由于它的源的单一话，代码实现不用写选择逻辑，很清晰；而对象的适配模式则可用于多源的适配，弥补了类适配模式的不足，使得原本用类适配模式需要写很多适配器的情况不复存在，弱点是，由于源的数目可以较多，所以具体的实现条件选择分支比较多，不太清晰。

**应用适配器模式的场景：**

1.系统需要使用现有的类，而现有类不符合当前系统的要求。如问题的提出。

2.系统要建立一个可以重复使用的类，用来与彼此没有太大关联的类或者在将来要引用的类一起工作。在Junit中有使用适配器模式的情景。

**缺省的适配器模式(Default Adapter)：**缺省的适配器模式为一个接口提供缺省的实现，子类可以从这个缺省的实现类进行扩展，而不必而原有的接口进行扩展。相信大家在学习Swing时“AWT中事件的处理”有所接触。他的好处在于客户端不需要去实现与他无关的方法，只做他最关心的事。

这种模式的核心归结如下：当你想实现一个接口但又不想实现所有接口方法，只想去实现一部分方法时，就用中默认的适配器模式，他的方法是在接口和具体实现类中添加一个抽象类，而用抽象类去空实现目标接口的所有方法。而具体的实现类只需要覆盖其需要完成的方法即可。

转自: [http://blog.csdn.net/leoleocmm/article/details/7593886][http_blog.csdn.net_leoleocmm_article_details_7593886]

[view plain]: http://blog.csdn.net/leroy008/article/details/8023722#
[http_blog.csdn.net_leoleocmm_article_details_7593886]: http://blog.csdn.net/leoleocmm/article/details/7593886