适配器模式

先看一个案例：

1.1 厨师主业务接口

package com.monkey1024.worker;

// 厨师主业务接口
public interface ICooker {
    
    // 烹饪
     String cookeing();

}

   

1.2.程序员主业务接口

package com.monkey1024.worker;

// 程序员主业务接口
public interface IProgrammer {

    // 编程
    String programming();

}

2.1 京东程序员

package com.monkey1024.worker.imp;

import com.monkey1024.worker.IProgrammer;


// 京东程序员 (实现类）
public class JdProgrammer implements IProgrammer {

    @Override
    public String programming() {
        return "码农：我能骚出一手好代码";
    }

}

2.2 全聚德厨师

package com.monkey1024.worker.imp;

import com.monkey1024.worker.ICooker;

// 全聚德厨师 (实现类)
public class QjdCooker implements ICooker {

    @Override
    public String cookeing() {
        return "厨师：我能烧出一只好鸭子";
    }

}

3 测试类

package com.monkey1024.test;

import com.monkey1024.worker.ICooker;
import com.monkey1024.worker.imp.JdProgrammer;
import com.monkey1024.worker.imp.QjdCooker;

public class MyTest {

    public static void main(String[] args) {
        
        // 雇一个全聚德的厨师
        ICooker c = new QjdCooker();
        
        // 抓一个京东的程序员
        JdProgrammer p = new JdProgrammer();
        
        // 分别做自我技艺介绍
        
        System.out.println(c.cookeing());
        
        System.out.println(p.programming());
        

    }

}

运行结果：

厨师：我能烧出一只好鸭子
码农，我能骚出一手好代码

---

使用一个适配器编程：

1.1 厨师主业务接口

1 package com.monkey1024.worker;
2 
3 // 厨师主业务接口
4 public interface ICooker {
5     
6     // 烹饪
7      String cookeing();
8 
9 }

   

1.2.程序员主业务接口

1 package com.monkey1024.worker;
2 
3 // 程序员主业务接口
4 public interface IProgrammer {
5 
6     // 编程
7     String programming();
8 
9 }

2.1 京东程序员

 1 package com.monkey1024.worker.imp;
 2 
 3 import com.monkey1024.worker.IProgrammer;
 4 
 5 
 6 // 京东程序员 (实现类）
 7 public class JdProgrammer implements IProgrammer {
 8 
 9     @Override
10     public String programming() {
11         return "码农：我能骚出一手好代码";
12     }
13 
14 }

2.2 全聚德厨师

 1 package com.monkey1024.worker.imp;
 2 
 3 import com.monkey1024.worker.ICooker;
 4 
 5 // 全聚德厨师 (实现类)
 6 public class QjdCooker implements ICooker {
 7 
 8     @Override
 9     public String cookeing() {
10         return "厨师：我能烧出一只好鸭子";
11     }
12 
13 }

3.1 适配器接口

 1 package com.monkey1024.adapters;
 2 
 3 // 适配器接口
 4 public interface IWorkerAdapter {
 5     
 6     // 形参是Object类型的工作岗位
 7     // 你给我传一个什么岗位，我就给你相应的String类型的工作
 8     String work(Object worker);
 9     
10 }

3.2 适配器类

 1 package com.monkey1024.adapters.impl;
 2 
 3 import com.monkey1024.adapters.IWorkerAdapter;
 4 import com.monkey1024.worker.ICooker;
 5 import com.monkey1024.worker.IProgrammer;
 6 
 7 
 8 // 适配器类！！！
 9 public class WorkerAdapter implements IWorkerAdapter {
10 
11     @Override
12     public String work(Object worker) {
13         
14         // 给工作内容赋值一个 空字符串 。 
15         String workContent ="";
16         
17         //做判断
18         
19         // 判断传过来的对象是不是 一个 厨师类型，是则调用其cookeing()
20         if(worker instanceof ICooker) {
21             
22             // 厨师向经理介绍自己的技能
23             workContent =((ICooker) worker).cookeing();  
24             
25             
26             // 判断传递过来的是不是 一个 程序员类型,是则调用其programming()
27         }else if(worker instanceof IProgrammer){
28             
29             // 程序员向经理介绍自己的技能
30             workContent =((IProgrammer) worker).programming();
31             
32         }else {
33             System.out.println("抱歉，你不是我们要招聘的人才类型");
34             
35         }
36         
37         return workContent;
38     }
39 
40 }

4. 测试类

package com.monkey1024.test;

import com.monkey1024.adapters.IWorkerAdapter;
import com.monkey1024.adapters.impl.WorkerAdapter;
import com.monkey1024.worker.ICooker;
import com.monkey1024.worker.imp.JdProgrammer;
import com.monkey1024.worker.imp.QjdCooker;

public class MyTest {

    public static void main(String[] args) {
        
        // 雇一个全聚德的厨师
        ICooker c = new QjdCooker();
        
        // 抓一个京东的程序员
        JdProgrammer p = new JdProgrammer();
        
         
        // 建一个Object数组，用于存放 这些 员工们
        Object[] workers = {c , p};
        
        
        // 创建适配器对象
        IWorkerAdapter adapter = new WorkerAdapter();
        
        
        // 循环遍历每个工种对象，让每个工种对象在适配器中逐个进行匹配
        for (Object worker  : workers) {
            
            
            String workContent = adapter.work(worker);
            
            // 输出 员工工种 的相应工作内容
            System.out.println(workContent);
            
        }

    }

}

运行结果：

厨师：我能烧出一只好鸭子
码农：我能骚出一手好代码

---

使用多个适配器编程：(推荐使用这种，因为在后期的框架源码中 使用的就是这种）

1 -2 步骤代码与上个案例的一样.

3.1 总适配器接口

package com.monkey1024.adapters;

// 总适配器接口
public interface IWorkerAdapter {
    
    // 形参是Object类型的工作岗位
    // 你给我传一个什么工种，我就给你相应的String类型的工作
    String work(Object worker);
    
    
    // 判断 工种与适配器是否 对应
    boolean supports(Object worker);
    
}

3.2 厨师适配器类

package com.monkey1024.adapters.impl;

import com.monkey1024.adapters.IWorkerAdapter;
import com.monkey1024.worker.ICooker;

// 厨师适配器类
public class CookerAdapter implements IWorkerAdapter {

    @Override
    public String work(Object worker) {
        
        // 返回 厨师 对应的工作内容
        return ((ICooker)worker).cookeing();
        
    }

    @Override
    public boolean supports(Object worker) {
        
        // 判断 worker是不是 厨师
        return (worker instanceof ICooker); 
    }

}

3.3 程序员适配器类

package com.monkey1024.adapters.impl;

import com.monkey1024.adapters.IWorkerAdapter;
import com.monkey1024.worker.IProgrammer;

// 程序员接口
public class ProgrammerAdapter implements IWorkerAdapter {

    @Override
    public String work(Object worker) {
        //// 返回 程序员 对应的工作内容
        return ((IProgrammer)worker).programming();
    }

    @Override
    public boolean supports(Object worker) {
        // 判断工种是不是 程序员
        return (worker instanceof IProgrammer);
    }

}

4. 测试类

package com.monkey1024.test;

import java.util.ArrayList;
import java.util.List;

import com.monkey1024.adapters.IWorkerAdapter;
import com.monkey1024.adapters.impl.CookerAdapter;
import com.monkey1024.adapters.impl.ProgrammerAdapter;
import com.monkey1024.worker.ICooker;
import com.monkey1024.worker.imp.JdProgrammer;
import com.monkey1024.worker.imp.QjdCooker;

public class MyTest {

    public static void main(String[] args) {
        
        // 雇一个全聚德的厨师
        ICooker c = new QjdCooker();
        // 抓一个京东的程序员
        JdProgrammer p = new JdProgrammer();
         
        // 建一个Object数组，用于存放 这些 员工们
        Object[] workers = {c , p};
        
         
        // 循环遍历每个工种对象，让每个工种对象在适配器中逐个进行匹配
        for (Object worker  : workers) {
            
            // 拿到该 工种对应的适配器
            // 怎么拿？先拿到所有的适配器，再在其中寻找自己要的
                  IWorkerAdapter adapter= getAdapter(worker);
                  System.out.println(adapter.work(worker));
        }

    }

    
    // 根据worker获取相应的适配器对象
    private static IWorkerAdapter getAdapter(Object worker) {
        
        // 先拿到所有的适配器
        List<IWorkerAdapter> adapters = getAllAdapters();
        
        // 遍历所有的适配器
        for (IWorkerAdapter adapter : adapters) {
            
            // 如果 传递进来的工种 能够 匹配上 对应的 适配器
            if(adapter.supports(worker)) {
                
                return adapter;
                
            }
        }
        return null;
        
    }

    // 获取所有的适配器
    private static List<IWorkerAdapter> getAllAdapters() {
        
        // 创建一个list集合 ，用于存放 所有的适配器
        List<IWorkerAdapter> adapters = new ArrayList<>();    
        
        // 存放 厨师适配器
        adapters.add(new CookerAdapter());
        
        // 存放 程序员适配器
        adapters.add(new ProgrammerAdapter());
        
        
        // 返回这个List集合
        return adapters;
    }
    
     

}

---

缺省适配器模式   (是适配器模式的简易版)

　　缺省适配器模式是由适配器模式简化而来，省略了适配器模式中目标接口，也就是源接口和目标接口相同，源接口为接口，目标接口为类。

　　典型的缺省适配器模式是 JavaEE 规范中的 Servlet 接口与 GenericServlet 抽象类。

　　Servlet 接口中包含五个抽象方法，而其中的 service()方法才是用于实现业务逻辑的、必须要实现的方法，另外四个方法一般都是空实现，或简单实现。

　　GenericServlet 抽象类实现了 Servlet 接口的 service()方法以外的另外四个方法，所以自定义的 Servlet 只需要继承 GenericServlet 抽象类，实现 service()方法即可。无需再实现Servlet 接口了。

---

---