设计模式之适配器模式

适配器模式:

类适配器模式、对象适配器模式、接口适配器模式

1.类适配器模式：新的接口出现了，但是和老的接口不兼容，这个时候，可以采用一个适配器类继承老的业务类并实现新的接口，这样就可以同时处理新老业务了。
示例代码

/** 
 * 原始类 
 */  
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

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

/** 
 * 原始类 
 */  
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

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

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