设计模式—适配器模式

转载请注明出处： http://blog.csdn.net/singwhatiwanna/article/details/17659905

前言

适配器模式在设计模式体系中属于结构型模式，可以分为三类：类的适配器模式、对象的适配器模式和接口的适配器模式，由于类和接口的适配器模式需要适配器继承原有的类，而纯面向对象语言Java、C#都是不支持多继承的，这在一定程度上制约了类和接口的适配器模式的使用场景，故使用的时候要注意。

使用目的：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

类适配器模式

说明：

当新接口出现的时候，由于和老的接口不兼容，这个时候，我们采用一个适配器类实现新的接口并且继承老的业务类，这样就能同时处理新老业务。

示例代码：

/**
 * 原始类
 */
class Source {
    public void oldFunction() {
        System.out.println("oldFunction:Source");
    }
}

interface Target {
    void oldFunction();

    // 新接口
    void newFunction();
}

// 适配器，用来做接口转换
class Adapter extends Source implements Target {

    public Adapter() {
        super();
    }

    @Override
    public void newFunction() {
        System.out.println("newFunction:Adapter");
    }
}

public class A {
    public static void main(String args[]) {
        Target target = new Adapter();
        target.oldFunction();
        target.newFunction();
    }
}

输出：

oldFunction:Source
newFunction:Adapter

 

对象适配器模式

说明：当新接口出现的时候，由于和老的接口不兼容，这个时候，我们采用一个适配器类实现新的接口并在内部持有一个老业务逻辑的对象，这样就能把对老接口的调用全部中转给老的业务逻辑，从而解决接口的兼容性问题

示例代码：

/**
 * 原始类
 */
class Source {
    public void oldFunction() {
        System.out.println("oldFunction:Source");
    }
}

interface Target {
    void oldFunction();

    // 新接口
    void newFunction();
}

// 适配器，用来做接口转换
class Adapter implements Target {

    // 适配器内部持有的原始类对象
    private Source mSource;

    public Adapter(Source source) {
        mSource = source;
    }

    @Override
    public void oldFunction() {
        // 这里调用原始类中的方法
        mSource.oldFunction();
    }

    @Override
    public void newFunction() {
        System.out.println("newFunction:Adapter");
    }

}

public class A {
    public static void main(String args[]) {
        Source source = new Source();
        Target target = new Adapter(source);
        target.oldFunction();
        target.newFunction();
    }
}

输出：

oldFunction:Source
newFunction:Adapter

 

接口适配器模式

说明：也叫缺省适配器模式，主要解决接口的复用问题：有时候可能我们的业务只需要使用接口中的某一个方法而不是全部方法，但是由于接口的语言特性而不得不实现全部的抽象方法，这样就会使得接口的使用过程很麻烦，特别是接口中存在很多抽象方法的时候。面对接口的这类问题，我们可以采用一个抽象类（也可以不是抽象类）去实现接口，然后让我们的类去继承这个抽象类同时只重写我们感兴趣的方法即可。

示例代码：

interface Target {
    void function1();

    void function2();

    void function3();

    void function4();
}

//TargetWrapper实现了Target接口，并给出了默认实现
abstract class TargetWrapper implements Target {
    @Override
    public void function1() {
        System.out.println("function1:TargetWrapper");
    }

    @Override
    public void function2() {
    }

    @Override
    public void function3() {
    }

    @Override
    public void function4() {
    }
}

// 适配器，继承TargetWrapper，重写自己感兴趣的方法
class Adapter extends TargetWrapper {

    public Adapter() {
        super();
    }

    @Override
    public void function2() {
        System.out.println("function4:Adapter");
    }
}

public class A {
    public static void main(String args[]) {
        Target target = new Adapter();
        target.function1();
        target.function2();
    }
}

输出：

function1:TargetWrapper
function4:Adapter

来源：oschina

链接：https://my.oschina.net/u/2336511/blog/392398