设计模式

适配器模式，从名字上就可以看出部分意思。适配器，大家在生活中最常见的就是电源适配器，功能就是给各种电器供电的（获取用来充电），为什么要有电源适配器，因为我们的电器，比如手机，手机是没有办法直接放在插座上进行充电的，因为接口不匹配，没有办法进行充电，只有通过电源适配器，一端可以插在插座上，一端连接在手机上，这样才能完成手机的充电。电源适配器在中间就起到了一个接口转换的功能，

适配器的定义就是用来适配一些原本不支持的接口，将原来不支持的接口可以转变位现在支持的接口的一种设备。

从文字上来说，大家都有一个粗略的认识了。但是还是不太深刻。

根据我的理解，适配的深度，解耦程度不同，分为三种适配器方式：1.类适配器、2.对象适配器、3.接口适配器

我们先来看代码：

现在有这样的一个原始类：

Source.java

package com;public class Source {    public void method() {        System.out.println("this is origal method");    }}

目标接口类ITarget.java

package com;public interface ITarget {    public void method();    public void newMethod();}

一、类适配器

类适配器就是生成一个新的类，它继承了原来的类，并且在新类上实现了新的接口。如下：

TargetClassAdapter.java

package com.classAdapter;import com.ITarget;import com.Source;public class TargetClassAdapter extends Source implements ITarget {    @Override    public void newMethod() {        // TODO Auto-generated method stub        System.out.println("this is new method");    }}

这样这个新类不仅可以使用原来了的方法，还实现了目标接口的方法。

测试代码：

TestClassAdapter.java

package com.classAdapter;public class TestClassAdapter {    public static void main(String[] args) {        // TODO Auto-generated method stub        ITarget target = new TargetClassAdapter();        target.method();        target.newMethod();    }}

二、对象适配器

对象适配器，适配的是原来的类的对象，不需要新增一个继承了原类的新的类：

TargetObjectAdapter.java

package objectAdapter;import com.ITarget;import com.Source;public class TargetObjectAdapter implements ITarget {    private Source source;    public TargetObjectAdapter(Source source) {        this.source = source;    }    @Override    public void method() {        // TODO Auto-generated method stub        source.method();    }    @Override    public void newMethod() {        // TODO Auto-generated method stub        System.out.println("This is a new method from object adapter");    }}

我们 可以看到在这个适配器中，持有的是原来的类的一个对象，而不是完整的去继承之前的类。

测试类：

package objectAdapter;import com.ITarget;import com.Source;public class ObjectAdapterTest {    public static void main(String[] args) {        Source source = new Source();        ITarget adapter = new TargetObjectAdapter(source);        adapter.method();        adapter.newMethod();    }}

三、接口适配器

看了上面两种模式，发现有一个问题，如果我们不需要实现全部的方法，比如要求的接口是这样的：

package interfaceAdapter;public interface INewTarget {    public void method1();    public void method2();    public void method();}

里面有三个接口，在不同的环境下，我需要实现不同的接口，比如A只需要实现method1()，B只需要实现method2()，很明显，使用上面那两个模式就不能够满足这样的需求了。因此我们需要给这个接口再套一层外包装将里面的接口都封装一下：

AbsTargetAdapter.java

package interfaceAdapter;import com.Source;public abstract class AbsTargetAdapter extends Source implements INewTarget {    @Override    public void method1() {        // TODO Auto-generated method stub    }    @Override    public void method2() {        // TODO Auto-generated method stub    }}

接下来我们只需要继承这个类，并且实现我们自己想要的内容就好了，它不仅仅继承了原始类的方法，还扩展了新的方法。
这样针对不同的A，B的需求去实现具体的适配器类了。

ATargetAdapter.java

package interfaceAdapter;public class ATargetAdapter extends AbsTargetAdapter {    @Override    public void method1() {        // TODO Auto-generated method stub        System.out.println("This is method1 from new ATargetAdapter");    }}

A中仅仅只需要实现method1()方法，

BTargetAdapter.java

package interfaceAdapter;public class BTargetAdapter extends AbsTargetAdapter {    @Override    public void method2() {        // TODO Auto-generated method stub        System.out.println("This is method2 from new BTargetAdapter");    }}

B中仅仅需要实现method2()方法
测试类：

InterfaceAdapterTest.java

package interfaceAdapter;public class InterfaceAdapterTest {    public static void main(String[] args) {        // TODO Auto-generated method stub        INewTarget target1 = new ATargetAdapter();        target1.method();        target1.method1();        target1.method2();        System.out.println();        INewTarget target2 = new BTargetAdapter();        target2.method();        target2.method1();        target2.method2();    }}

测试结果：

this is origal methodThis is method1 from new ATargetAdapterthis is origal methodThis is method2 from new BTargetAdapter

可以从结果中看到，A adapter中不需要 也 没有去实现method2()方法，因此在调用之后没有任何作用，同理，B中也没有method1()方法。

结论：适配器模式：就是通过一些方式将一个原本已经完善的类，在不改变原来类结构的基础上，扩展出一些新的需要的接口，实现这些新的接口，产生一个新的类，用于后面继续使用。在这个基础上，甚至可以去覆盖替换原来的一些类接口。

这样的做法就是很好的保存了原始类的结构，只做到了扩展，而不去动原来的东西。

水平有限，请大神们 多多指正~