java 适配器模式

一、适配器模式的定义是：将某个类的接口转换为接口客户所需的类型，即解决的目的是，使原本由于接口不兼容而不能一起工作，不能一起管理的哪些类可以在一起工作，可以进行统一管理。

二、定义比较抽象，下面以不同工种的不同工作内容为例，实现统一管理来解释适配器模式。

需求：厨师的工作是cook()，程序员的工作是program()，不同的工种有着不同的工作内容，现在程序要讲（假如有30个工种）的工作内容全部输出。

解决方法1：逐个遍历每个对象的具体的工作方法，很明显，缺点是无法循环遍历，无法统一管理。

解决方法2：使用我们的适配器模式：

这里有厨师接口ICooker，程序员接口IProgram，分别用于定义他们工种的具体工作。

接着是，定义新东方的厨师XinCooker以及饿了么的程序员EleProgram。。

此时不同工种的具体工作是不同的，无法进行统一管理以及协同合作，所以定义一个员工适配器接口IWorkAdapter，

将这些工种进行管理。

案例1：使用一个适配器进行管理

项目结构：

详细代码：

1、厨师接口：

package me.ele.work;

/**
 * 厨师接口
 * @author LZJ
 * @create 2018-07-20 19:29
 **/
public interface ICooker {
    String cook();
}

2、程序员接口

package me.ele.work;

/**
 * 程序员接口
 * @author LZJ
 * @create 2018-07-20 19:29
 **/
public interface IProgramer {
    String program();
    
}

3、厨师实现类（新东方厨师）

package me.ele.work.imp;

import me.ele.work.ICooker;

/**
 * 厨师实现类
 * @author LZJ
 * @create 2018-07-20 19:30
 **/
public class XinDongFangCooker implements ICooker{
    public String cook() {
        return "新东方的招牌菜 真好吃";
    }
}

4、程序员实现类（饿了么攻城狮）

package me.ele.work.imp;

import me.ele.work.IProgramer;

/**
 * 程序员实现类
 * @author LZJ
 * @create 2018-07-20 19:31
 **/
public class ElemeProgramer implements IProgramer {
    public String program() {
        return "eleme 的攻城狮写的一手好代码";
    }
}

5、适配器接口

package me.ele.adapters;

/**
 * @author LZJ
 * @create 2018-07-20 19:33
 **/
public interface IWorkAdapter {
    /**
     * 这里由于所有的worker都可以使用Object来表示，所以使用Object来声明
     * @param worker
     * @return
     */
    String work(Object worker);
}

6、适配器接口实现类（工种适配器）

package me.ele.adapters;

import me.ele.work.ICooker;
import me.ele.work.IProgramer;

/**
 * 适配器类
 * @author LZJ
 * @create 2018-07-20 19:33
 **/
public class IWorkAdapterImpl implements IWorkAdapter {
    public String work(Object worker) {
        String workContent = "";

        //根据传来的对象转换为相应的接口，然后调用自己的方法
        if(worker instanceof ICooker) {
            ICooker cooker = (ICooker) worker;
            workContent = cooker.cook();
        }else if(worker instanceof IProgramer){
            IProgramer programer = (IProgramer) worker;
            workContent = programer.program();
        }

        return workContent;
    }
}

7、测试类：

package me.ele;

import me.ele.adapters.IWorkAdapter;
import me.ele.adapters.IWorkAdapterImpl;
import me.ele.work.ICooker;
import me.ele.work.IProgramer;
import me.ele.work.imp.ElemeProgramer;
import me.ele.work.imp.XinDongFangCooker;

/**
 * @author LZJ
 * @create 2018-07-20 19:40
 **/
public class Test {
    public static void main(String[] args){

        //new出不同工种的对象
        ICooker iCooker = new XinDongFangCooker();
        IProgramer iProgramer = new ElemeProgramer();

        //添加至一个数组中，以便于我们遍历每一个工种对象
        Object[] workers = {iCooker,iProgramer};

        //new 一个适配器
        IWorkAdapter iWorkAdapter = new IWorkAdapterImpl();
        for (Object worker : workers) {
            String workContent = iWorkAdapter.work(worker);//传入工种对象，逐个匹配，进行适配
            System.out.println(workContent);
        }
    }
}

8、输出结果：

案例2：每个工种定义一个适配器

项目结构

详细代码：

1、厨师接口：

package me.ele.work;

/**
 * @author LZJ
 * @create 2018-07-20 20:04
 **/
public interface ICooker {
    String cook();
}

2、程序员接口：

package me.ele.work;

/**
 * @author LZJ
 * @create 2018-07-20 20:04
 **/
public interface IProgramer {
    String program();
}

3、厨师实现类（新东方厨师）：

package me.ele.work.impl;

import me.ele.work.ICooker;

/**
 * @author LZJ
 * @create 2018-07-20 20:05
 **/
public class XinDongFangCooker implements ICooker {
    public String cook() {
        return "新东方的招牌菜 真好吃";
    }
}

4、程序员实现类（饿了么攻城狮）：

package me.ele.work.impl;

import me.ele.work.IProgramer;

/**
 * @author LZJ
 * @create 2018-07-20 20:05
 **/
public class ElemeProgramer implements IProgramer {
    public String program() {
        return "eleme 的攻城狮写的一手好代码";
    }
}

5、适配器接口：

package me.ele.adapters;

/**
 * @author LZJ
 * @create 2018-07-20 20:05
 **/
public interface IWorkAdapter {
    String work(Object worker);

    //用来判断 适配器是否支持该 worker对象
    boolean support(Object worker);
}

6、适配器实现类1（厨师适配器）

package me.ele.adapters.impl;

import me.ele.adapters.IWorkAdapter;
import me.ele.work.ICooker;

/**
 * @author LZJ
 * @create 2018-07-20 20:07
 **/
public class CookerAdapter implements IWorkAdapter {
    public String work(Object worker) {
        return ((ICooker) worker).cook();
    }

    public boolean support(Object worker) {
        return (worker instanceof ICooker);
    }
}

7、程序员适配器：

package me.ele.adapters.impl;

import me.ele.adapters.IWorkAdapter;
import me.ele.work.IProgramer;

/**
 * @author LZJ
 * @create 2018-07-20 20:08
 **/
public class ProgramerAdapter implements IWorkAdapter {
    public String work(Object worker) {
        return ((IProgramer) worker).program();
    }

    public boolean support(Object worker) {
        return (worker instanceof IProgramer);
    }
}

8、测试类：

package me.ele;

import me.ele.adapters.IWorkAdapter;
import me.ele.adapters.impl.CookerAdapter;
import me.ele.adapters.impl.ProgramerAdapter;
import me.ele.work.ICooker;
import me.ele.work.IProgramer;
import me.ele.work.impl.ElemeProgramer;
import me.ele.work.impl.XinDongFangCooker;

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

/**
 * @author LZJ
 * @create 2018-07-20 20:10
 **/
public class Test {
    public static void main(String[] args){

        ICooker iCooker = new XinDongFangCooker();
        IProgramer iProgramer = new ElemeProgramer();
        List<Object> workers = Arrays.asList(iCooker, iProgramer);

        for (Object work : workers) {
            IWorkAdapter adapterByWorker = getAdapterByWorker(work);
            String workContent = adapterByWorker.work(work);
            System.out.println(workContent);
        }
    }

    /**
     * 根据worker获取对应的适配器对象
     * @param worker
     * @return
     */
    public static IWorkAdapter getAdapterByWorker(Object worker){
        List<IWorkAdapter> iWorkAdapters = getAllAdapterInstance();
        for (IWorkAdapter iWorkAdapter : iWorkAdapters) {
            if(iWorkAdapter.support(worker)){
                return iWorkAdapter;
            }
        }
        return null;
    }

    /**
     * 获取所有的 adapter实现类的对象
     * @return
     */
    public static List<IWorkAdapter> getAllAdapterInstance(){
        //这里其实应该用反射做的
        List<IWorkAdapter> iWorkAdapters = new ArrayList();
        iWorkAdapters.add(new CookerAdapter());
        iWorkAdapters.add(new ProgramerAdapter());
        return iWorkAdapters;
    }
}

9、运行结果：

案例1：使用一个适配器进行管理

案例2：每个工种定义一个适配器

猜你喜欢