关于java:设计模式62-再聊聊适配器模式

这里说的适配器不是通常所说的类适配器，对象适配器，接口适配器，这里实现的是把所有的类进行对立治理的适配器。如须要查找设计模式的三种次要适配器模式，请点击https://blog.csdn.net/Aphysia…

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

能够这么了解，原来可能两个接口或者两个类不兼容，适配器模式要做的事件就是把它们对立治理，让他们能够一起工作。举个简略的例子：内存卡和笔记本，是不能间接连贯工作的，然而咱们应用读卡器，相当于适配器，把它们连接起来了。

1.不应用适配器的例子：

•   需要:程序猿的工作是program()，老师的工作是teach(),那么这些不同的职业，具体的工作都是不一样的，这些程序猿program()办法内容也可能是不一样的，比如说京东，阿里，腾讯等等，老师也是一样的，不同学校的老师工作内容也各异。所以咱们必须定义接口，不同工作内容的也能够通过实现本人的接口去实现。

  代码后果如下：

  IProgramer.class(程序猿撸代码的接口)

package com.noadapter;

public interface IProgramer {
    public void program();
}

  Programer.class(程序猿的类，实现了撸代码的接口)

package com.noadapter;

public class Programer implements  IProgramer {
    @Override
    public void program() {
        System.out.println("我是一个优良的程序猿，我终日撸代码");
    }
}

  上面的老师接口以及实现老师的类也和下面程序猿的一样：

ITeacher.class(老师教书接口):

package com.noadapter;

public interface ITeacher {
    public void teach();
}

  Teacher.class(实现了教书的老师类):

package com.noadapter;

public class Teacher implements ITeacher {
    @Override
    public void teach() {
        System.out.println("我是老师，我教育祖国的花朵");
    }
}

  MyTest.class 测试类：

package com.noadapter;

public class MyTest {
    public static void main(String []args){
        ITeacher teacher = new Teacher();
        IProgramer programer = new Programer();
        //必须挨个拜访他们的办法
        teacher.teach();
        programer.program();
    }
}

运行后果：

了解：如果不是用适配器含糊，那么咱们要定义出所有的工种对象（程序猿，老师等等)，还要为他们实现各自的接口，而后对他们的办法进行调用，这样有多少个工种，就要写多少个办法调用，比拟麻烦。

2.只定义一个适配器实现类

在后面的根底上批改，减少了IWorkAdapter.class以及它的实现类WorkerAdapter.class,以及更改了测试方法，其余的都没有扭转，代码构造如下：

减少的IWorkAdapter.class(适配器的接口)：

public interface IWorkAdapter {
    //参数之所以是Object，是因为要兼容所有的工种对象
    public void work(Object worker);
}

减少的WorkAdapter.class(适配器的类):

public class WorkAdaper implements IWorkAdapter {
    @Override
    public void work(Object worker) {
        if(worker instanceof IProgramer){
            ((IProgramer) worker).program();
        }
        if(worker instanceof ITeacher){
            ((ITeacher) worker).teach();
        }
    }
}

更改过的测试类MyTest.class:

public class MyTest {
    public static void main(String []args){
        ITeacher teacher = new Teacher();
        IProgramer programer = new Programer();
        //把两个工种放到对象数组
        Object[] workers = {teacher,programer};
        //定义一个适配器
        IWorkAdapter adapter = new WorkAdaper();
        //适配器遍历对象
        for(Object worker:workers){
            adapter.work(worker);
        }
    }
}

后果仍然不变：

剖析：只写一个适配器，性能上就像是把接口集中到一起，在两头加了一层，这一层把调用不同工种（程序猿，老师）之间的差别屏蔽掉了，这样也达到理解耦合的作用。

3.多个适配器的模式

也就是为每一个工种都定义一个适配器（在一个适配器的根底上进行批改）

批改 IWorkAdapter.class

public interface IWorkAdapter {
    //参数之所以是Object，是因为要兼容所有的工种对象
    public void work(Object worker);
    //判断以后的适配器是否反对指定的工种对象
    boolean supports(Object worker);
}

定义一个TeacherAdapter.class

public class TeacherAdapter implements IWorkAdapter{
    @Override
    public void work(Object worker) {
        ((ITeacher)worker).teach();
    }

    @Override
    public boolean supports(Object worker) {
        return (worker instanceof ITeacher);
    }
}

定义一个ProgrammerAdapter.class

public class ProgrammerAdapter implements IWorkAdapter{
    @Override
    public void work(Object worker) {
        ((IProgramer)worker).program();

    }
    @Override
    public boolean supports(Object worker) {
        return (worker instanceof IProgramer);
    }
}

测试类（Test.class）:

public class MyTest {
    public static void main(String []args){
        ITeacher teacher = new Teacher();
        IProgramer programer = new Programer();
        //把两个工种放到对象数组
        Object[] workers = {teacher,programer};
        //适配器遍历对象
        for(Object worker:workers){
            IWorkAdapter adapter = getAdapter(worker);
            adapter.work(worker);
        }
    }
    public static IWorkAdapter getAdapter(Object object){
        IWorkAdapter teacherAdapter = new TeacherAdapter();
        IWorkAdapter programmerAdapter = new ProgrammerAdapter();
        IWorkAdapter[] adapters = {teacherAdapter,programmerAdapter};
        for(IWorkAdapter adapter:adapters){
            if(adapter.supports(object)){
                return adapter;
            }
        }
        return null;
    }
}

集体了解：其实多个适配器的基本是去获取反对该对象的适配器，通过该适配器来应用这个对象。