一、适配器模式的定义是:将某个类的接口转换为接口客户所需的类型,即解决的目的是,使原本由于接口不兼容而不能一起工作,不能一起管理的哪些类可以在一起工作,可以进行统一管理。
二、定义比较抽象,下面以不同工种的不同工作内容为例,实现统一管理来解释适配器模式。
需求:厨师的工作是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、运行结果: