设计模式之适配器模式详解

适配器模式的官方定义：将一个类的接口转换为客户期望的另外的一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

目的：消除由于接口不匹配造成的类的不兼容问题。

分类：有三类，主要是类的适配器模式，对象的适配器模式，接口的适配器模式。

1.类的适配器模式



核心思想：有一个源目标类，有一个method1()方法，目标接口是Targetable接口，通过适配器Adapter类，将Source的功能扩展到目标接口中。

1.类的适配器模式：

首先是我们的源目标类：

public class Source {

public void method1() {
System.out.println("this is original method!");
}
}

然后是我们的目标接口：

public interface Targetable {

/* 与原类中的方法相同 */
public void method1();

/* 新类的方法 */
public void method2();
}

最后就是我们的适配器：

public class Adapter extends Source implements Targetable {

@Override
public void method2() {
System.out.println("this is the targetable method!");
}
}

Adapter 继承
4000
源目标类，并且实现目标接口，下面是测试代码：

public class AdapterTest {

public static void main(String[] args) {
Targetable target = new Adapter();
target.method1();
target.method2();
}
}

输出：

this is original method!

this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能，就解决了由于接口不兼容而导致类不能一起工作的问题。

2.对象的适配器模式：

对象的适配器模式的核心思想跟类的适配器模式差不多一样，区别在于此时Adapter不继承Source类，而是拥有Source一个实例。

核心类图：



我们只是需要修改一下Adapter的代码即可：

public class Adapter implements Targetable {
private Source source;

public Wrapper(Source source){
super();
this.source = source;
}
@Override
public void method2() {
System.out.println("this is the targetable method!");
}
@Override
public void method1() {
source.method1();
}
}

测试代码：

public class AdapterTest {
public static void main(String[] args) {
Source source = new Source();
Targetable target = new Wrapper(source);

target.method1();
target.method2();
}
}

3.接口的适配器模式

首先我们先来看这么一个问题，就是在一个接口中我们写了很多个方法，如果我们要写该接口的实现类的时候又必须实现该接口的所有方法，但是有一些方法又不是我们所需要的，这个时候去实现完所有的方法实在是太浪费了。

这是接口的适配器模式就有很大的作用了，所谓的接口适配器模式，我们可以借助一个抽象类实现该接口，我们不去跟源接口打交道，而是用一个类去继承这个抽象类，只需要重写我们需要的方法即可。



源接口：

public interface Sourceable {

public void method1();
public void method2();
}
}

抽象类：

public abstract class Wrapper2 implements Sourceable{
public void method1(){}
public void method2(){}
}

比如我们只是需要method1()

public class SourceSub1 extends Wrapper2 {
public void method1(){
System.out.println("the sourceable interface's first Sub1!");
}
}

比如我们只是需要method2()

public class SourceSub2 extends Wrapper2 {
public void method2(){
System.out.println("the sourceable interface's first Sub2!");
}
}

最后是测试代码：

public class WrapperTest {

public static void main(String[] args) {
Sourceable source1 = new SourceSub1();
Sourceable source2 = new SourceSub2();

source1.method1();
source1.method2();
source2.method1();
source2.method2();
}
}

结果：

the sourceable interface’s first Sub1!

the sourceable interface’s second Sub2!

最后我们来总结一下适配器的使用场景：

1.类的适配器模式，当一个类需要转换成满足另外一个新接口的时候，可以使用类的适配器模式，创建一个新类，继承源类，现实新的接口就可以。

2.对象的适配器模式，当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

3.接口的适配器模式，当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。