java 设计模式之适配器模式

适配器模式是各种模式的起源



平时我们会经常碰到这样的情况，有了两个现成的类，它们之间没有什么联系，但是我们现在既想用其中一个类的方法，同时也想用另外一个类的方法。有一个解决方法是，修改它们各自的接口，但是这是我们最不愿意看到的。这个时候Adapter模式就会派上用场了。

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成

的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式

类的适配器



核心思想就是：有一个 Source 类，拥有一个方法，待适配，目标接口是 Targetable，通过 Adapter 类，

将 Source 的功能扩展到 Targetable 里，看代码：

待适配的类
public class Source {

public void methon1(){
System.out.println("this is source metho1");
}
}

接口：

public interface Targetable {

/**
* 于原生类方法相同
*/
public void methon1();
/**
* 新类的方法
*/
public void methon2();
}

适配开始：

public class Adapter extends Source implements Targetable{

@Override
public void methon2() {
System.out.println("this is targetable methon");

}

}

测试：

public class AdapterTest {
//这样 Targetable 接口的实现类就具有了 Source 类的功能。
public static void main(String[] args) {
Targetable t  =new  Adapter();
t.methon1();
t.methon2();
}
}

this is source metho1
this is targetable methon

这样 Targetable 接口的实现类就具有了 Source 类的功能。

2、对象的适配器

基本思路和类的适配器模式相同，只是将 Adapter 类作修改，这次不继承 Source 类，而是持有 Source

类的实例，以达到解决兼容性的问题。看图：

public class Wrapper implements Targetable{

private Source source;

public Wrapper(Source source) {
super();
this.source = source;
}

@Override
public void methon1() {
source.methon1();

}

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

}

}

测试：

/**
*  对象的适配器
* @author Administrator
*
*/
public class WrapperTest {

public static void main(String[] args) {

Wrapper w = new Wrapper(new Source());

w.methon1();
w.methon2();
}
}
this is source metho1
this is the targetable method
输出与第一种一样，只是适配的方法不同而已。

接口的适配器模式：

第三种适配器模式是接口的适配器模式，接口的适配器是这样的：有时我们写的一个接口中有多个抽象

方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所

有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，

借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和

该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。看一下类图：

/**
* 这个很好理解，在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以致于有时我们在一些
实现类中并不是都需要。看代码：
* @author Administrator
*
*/
public interface Sourceable {

public void method1();

public void method2();

}

public class SourceSub1 extends Wrapper2{

public void  method1(){
System.out.println("the sources interface's first sub1");
}
}

public class SourecSub2 extends Wrapper2{

public void method2(){

System.out.println("the sources interface's first sub2");
}
}

适配开始：

public abstract class Wrapper2 implements Sourceable{

public void method1(){};

public void method2(){};
}

测试：

public class SourceTest {

public static void main(String[] args) {

Sourceable sub1 = new SourceSub1();
Sourceable sub2 = new SourecSub2();
sub1.method1();
sub1.method2();
sub2.method1();
sub2.method2();
}
}
the sources interface's first sub1
the sources interface's first sub2

测试输出：

the sourceable interface’s first Sub1!

the sourceable interface’s second Sub2!

达到了我们的效果！

讲了这么多，总结一下三种适配器模式的应用场景：

类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一

个新类，继承原有的类，实现新的接口即可。

对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个 Wrapper 类，

持有原类的一个实例，在 Wrapper 类的方法中，调用实例的方法就行。

接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类 Wrapper，实现所

有方法，我们写别的类的时候，继承抽象类即可。

适配器模式的三个特点：

1 适配器对象实现原有接口

2 适配器对象组合一个实现新接口的对象（这个对象也可以不实现一个接口，只是一个单纯的对象）

3 对适配器原有接口方法的调用被委托给新接口的实例的特定方法

说句实话.我现在看几个设计模式.代码上相对来说不是那么复杂, 但是在工作中真正的用到确实不是那么容易.所以小伙伴们一定要坚持看完.多写多练 慢慢的在你写代码的时候.就会形成一种意识.让你觉得,还有更好的方式可以实现它.