设计模式之适配器模式

设计模式之适配器模式

概述

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

设计模式思想

由上图可见适配器模式中的角色共有3个：

• 目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。
• 需要适配的类（Adaptee）：需要适配的类或适配者类。
• 适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成目标接口。

设计模式的用法

类的适配器模式

核心思想就是：有一个Class类，拥有一个create方法；目标接口是 Targetable，通过Adapter 类，将 Class类的功能扩展到 Targetable 里。

代码
需要适配的类：

/**
 * 适配器模式——类的适配器
 * @author Administrator
 *实现类
 */
public class Class {

    public void create(){
        System.out.println("创建一个新类");
    }
}

目标接口：

/**
 * 适配器模式——类的适配器
 * @author Administrator
 *目标接口
 */
public interface Targetable {
    public void create();

    public void delete();
}

类适配器：

/**
 * 适配器模式——类的适配器
 * @author Administrator
 *类适配器
 */
public class ClassAdapter extends Class implements Targetable{

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("删除一个旧类");
    }

}

测试类：

/**
 * 适配器模式——类的适配器
 * @author Administrator
 *测试类
 */
public class TestClassAdapter {

    public static void main(String[] args) {
        Targetable targetable=new ClassAdapter();
        targetable.create();
        targetable.delete();
    }
}

测试结果：

创建一个新类
删除一个旧类

对象的适配器模式

对象适配与类适配的不同的在于适配对象的不同，因此代码的不同出在于适配器代码的不同。
需要适配的对象类

/**
 * 对象
 * @author Administrator
 *
 */
public class Object {
    public void create(){
        System.out.println("创建一个对象 ");
    }
}

/**
 * 适配器模式——对象的适配器
 * @author Administrator
 *目标接口
 */
public interface Targetable {
    public void create();

    public void delete();
}

对象适配器：

/**
 * 适配器模式——对象的适配器
 * @author Administrator
 *对象适配器
 */
public class ObjectAdapter implements Targetable {
    private Object object;

    public ObjectAdapter(Object object) {
        super();
        this.object = object;
    }

    @Override
    public void create() {
        // TODO Auto-generated method stub
      object.create();
    }

    @Override
    public void delete() {
        // TODO Auto-generated method stub
        System.out.println("删除一个旧的对象");
    }

}

测试类：

/**
 * 适配器模式——对象的适配器
 * @author Administrator
 *测试类
 */
public class TestObjectAdapter {

    public static void main(String[] args) {
    Object object=new Object();
    Targetable targetable=new ObjectAdapter(object);
    targetable.create();
    targetable.delete();

    }
}

测试效果同上述测试类的效果。

接口的适配器模式

接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
需要适配的接口：

/**
 * 适配器模式——接口的适配器
 * @author Administrator
 *需要适配的接口
 */
public interface MediaPlayer {

public void playerAudio();
public void playerVideo();

}

接口适配器：

/**
 * 适配器模式——接口的适配器
 * @author Administrator
 *接口适配器
 */
public  abstract class AudioPlayer implements MediaPlayer{

    @Override
    public void playerAudio() {
        // TODO Auto-generated method stub

    }

    @Override
    public void playerVideo() {
        // TODO Auto-generated method stub

    }

}

继承适配器的实体类：

/**
 * 适配器模式——接口的适配器
 * @author Administrator
 *继承适配器的实体类
 */
public class MP4Audio extends AudioPlayer{

    @Override
    public void playerAudio() {
        // TODO Auto-generated method stub
        System.out.println("正在播放MP4-Music");
    }
}

/**
 * 适配器模式——接口的适配器
 * @author Administrator
 *继承适配器的实体类
 */
public class MP3Audio extends AudioPlayer{

    @Override
    public void playerAudio() {
        // TODO Auto-generated method stub
        System.out.println("正在播放MP3-Music");
    }
}

测试类：

/**
 * 适配器模式——接口的适配器
 * @author Administrator
 *测试类
 */
public class TestInterfaceAdapter {

    public static void main(String[] args) {
        AudioPlayer mp3=new MP3Audio();
        AudioPlayer mp4=new MP4Audio();
        mp3.playerAudio();
        mp4.playerAudio();
    }
}

测试结果：

正在播放MP3-Music
正在播放MP4-Music

优缺点及使用场景

优点：
1、可以让任何两个没有关联的类一起运行。
2、提高了类的复用。
3、增加了类的透明度。
4、灵活性好。
缺点：
1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。
2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。
使用场景：
1、有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。
2、系统需要使用现有的类，而这些类的接口不符合系统的接口。
3、两个类所做的事情相同或相似，但是具有不同接口的时候。
4、使用第三方组件，组件接口定义和自己定义的不同，不希望修改自己的接口，但是要使用第三方组件接口的功能