适配器模式

一、适配器模式

        在计算机编程中，适配器模式（有时候也称包装样式或者包装）将一个类的接口适配成用户所期待的。一个适配允许通常因为接口不兼容而不能在一起工作的类工作在一起，做法是将类自己的接口包裹在一个已存在的类中。

二、适用情况

 使用的前提：

1．接口中规定了所有要实现的方法

2．但一个要实现此接口的具体类，只用到了其中的几个方法，而其它的方法都是没有用的。

 实现方法：

1．用一个抽象类实现已有的接口，并实现接口中所规定的所有方法，这些方法的实现可以都是“平庸”实现----空方法；但此类中的方法是具体的方法，而不是抽象方法，否则的话，在具体的子类中仍要实现所有的方法，这就失去了适配器本来的作用。

2．原本要实现接口的子类，只实现1中的抽象类即可，并在其内部实现时，只对其感兴趣的方法进行实现。

三、使用一个适配器编程

1 package com.jmu.worker;
2 
3 public interface IProgrammer {
4  String programmer();
5  
6 }

 

1 package com.jmu.worker;
2 
3 public interface ICooker {
4  String cooker();
5  
6 }

 1 package com.jmu.worker.impl;
 2 
 3 import com.jmu.worker.IProgrammer;
 4 
 5 public class JdProgrammer implements IProgrammer {
 6 
 7     @Override
 8     public String programmer() {
 9         // TODO Auto-generated method stub
10         
11         return "编写高效程序";
12     }
13 
14 }

package com.jmu.worker.impl;

import com.jmu.worker.ICooker;

public class JmuCooker implements ICooker{

    @Override
    public String cooker() {
        // TODO Auto-generated method stub
        
        return "沙茶面";
    }

}

1 package com.jmu.adapters;
2 
3 public interface IWorkerAdapter {
4  String work(Object worker);
5 }

 1 package com.jmu.adapters.impl;
 2 
 3 import com.jmu.adapters.IWorkerAdapter;
 4 import com.jmu.worker.ICooker;
 5 import com.jmu.worker.IProgrammer;
 6 //适配器类
 7 public class WorkerAdapeterImpl implements IWorkerAdapter {
 8 
 9     @Override
10     public String work(Object worker) {
11         // TODO Auto-generated method stub
12         String workerContent="";
13         //若传来的是厨师，则调用cooker()方法
14         if(worker instanceof ICooker){//instanceof:它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。
15             workerContent=((ICooker)worker).cooker();
16         }else if (worker instanceof IProgrammer) {
17             workerContent=((IProgrammer)worker).programmer();
18         }
19         return workerContent;
20     }
21 
22 }

 1 package com.jmu.test;
 2 
 3 import com.jmu.adapters.IWorkerAdapter;
 4 import com.jmu.adapters.impl.WorkerAdapeterImpl;
 5 import com.jmu.worker.ICooker;
 6 import com.jmu.worker.IProgrammer;
 7 import com.jmu.worker.impl.JdProgrammer;
 8 import com.jmu.worker.impl.JmuCooker;
 9 
10 public class MyTest {
11 
12     public static void main(String[] args) {
13         // TODO Auto-generated method stub
14         ICooker jmuCooker=new JmuCooker();
15         IProgrammer jdProgrammer=new JdProgrammer();
16         IWorkerAdapter iWorkerAdapter=new WorkerAdapeterImpl();
17         Object[] works={jmuCooker,jdProgrammer};
18         for (Object worke : works) {
19             String workContent = iWorkerAdapter.work(worke);
20             System.out.println(workContent);
21         }
22     }
23 
24 }

运行结果：

沙茶面
编写高效程序

四、多个适配器编程

 

1 package com.jmu.adapters;
2 
3 public interface IWorkerAdapter {
4  String work(Object worker);
5  boolean supports(Object worker);
6  
7 }

 1 package com.jmu.adapters.impl;
 2 
 3 import com.jmu.adapters.IWorkerAdapter;
 4 import com.jmu.worker.ICooker;
 5 
 6 public class CookerAdapter implements IWorkerAdapter {
 7 
 8     @Override
 9     public String work(Object worker) {
10         // TODO Auto-generated method stub
11         return  ((ICooker)worker).cooker();
12     }
13 
14     @Override
15     public boolean supports(Object worker) {
16         // TODO Auto-generated method stub
17         return (worker instanceof ICooker);
18     }
19 
20 }

 1 package com.jmu.test;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 import com.jmu.adapters.IWorkerAdapter;
 7 import com.jmu.adapters.impl.CookerAdapter;
 8 import com.jmu.adapters.impl.ProgrammerAdapter;
 9 import com.jmu.worker.ICooker;
10 import com.jmu.worker.IProgrammer;
11 import com.jmu.worker.impl.JdProgrammer;
12 import com.jmu.worker.impl.JmuCooker;
13 
14 public class MyTest {
15 
16     public static void main(String[] args) {
17         // TODO Auto-generated method stub
18         ICooker jmuCooker=new JmuCooker();
19         IProgrammer jdProgrammer=new JdProgrammer();
20       //循环遍历每个工种对象，让每个工种对象在适配器中逐个进行匹配
21         Object[] works={jmuCooker,jdProgrammer};
22         for (Object worker : works) {
23             IWorkerAdapter adapter=getAdapter(worker);
24             System.out.println(adapter.work(worker));
25             
26         }
27     } 
28 //根据worker获取相应的适配器对象
29     private static IWorkerAdapter getAdapter(Object worker) {
30         // TODO Auto-generated method stub
31         List<IWorkerAdapter>  adapters=getAllAdapters();
32         for (IWorkerAdapter adapter : adapters) {
33             if(adapter.supports(worker)){
34                 return adapter;
35             }
36         }
37         return null;
38     }
39 //获取所有的适配器
40     private static List<IWorkerAdapter> getAllAdapters() {
41         // TODO Auto-generated method stub
42     List<IWorkerAdapter> adapters=new ArrayList<IWorkerAdapter>();
43     adapters.add(new CookerAdapter());
44     adapters.add(new ProgrammerAdapter());
45         return adapters;
46     }
47 
48 }

五、缺省适配器模式

转载于:https://www.cnblogs.com/hoje/p/8085545.html