适配器模式

1. 适配器的原理

火鸡冒充鸭子

一个公司做鸭子产品，一个公司做火鸡产品。

如果火鸡公司想要做鸭子产品，通过火鸡适配器，让火鸡在外界的形象看起来就是鸭子，但内部所调用的东西都依然是火鸡的。

代码实现

对象适配器
构造方法内传入的是需要被适配的那个对象

/**
 * 火鸡冒充鸭子
 * Created by Administrator on 2017/6/24.
 */
public interface Duck {
    public void quack();
    public void fly();
}
/**
 * 鸭子实现类，绿头鸭
 * Created by Administrator on 2017/6/24.
 */
public class GreenHeadDuck implements Duck {
    public void quack() {
        System.out.println("Ga Ga Ga");
    }

    public void fly() {
        System.out.println("I am flying a long distance");
    }
}

/**
 * 火鸡接口
 * Created by Administrator on 2017/6/24.
 */
public interface Turkey {
    public void gobble();
    public void fly();
}
/**
 * 火鸡实现类，野火鸡
 * Created by Administrator on 2017/6/24.
 */
public class WildTurkey implements Turkey {
    public void gobble() {
        System.out.println("Go Go Go");
    }

    public void fly() {
        System.out.println("I am flying a short distance");
    }
}
/**
 * 火鸡适配器，对外展现鸭子的特性，方法是鸭子的方法，调用内容依旧是火鸡
 * Created by Administrator on 2017/6/24.
 */
public class TurkeyAdapter implements Duck {
    private Turkey turkey;

    public TurkeyAdapter(Turkey turkey){
        this.turkey = turkey;
    }

    public void quack() {
        turkey.gobble();
    }

    public void fly() {
        for(int i=0;i<5;i++){
            turkey.fly();
        }
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        GreenHeadDuck greenHeadDuck = new GreenHeadDuck();
        WildTurkey wildTurkey = new WildTurkey();

        Duck duck = new TurkeyAdapter(wildTurkey);
        greenHeadDuck.quack();
        greenHeadDuck.fly();
        wildTurkey.gobble();
        wildTurkey.fly();
        duck.quack();
        duck.fly();
    }
}

2. 对象适配器和类适配器

类适配器

适配器要继承被适配者的类，和实现目标接口。

/*
 *适配器的类，其他类同上  
 *需要将火鸡转为鸭子，火鸡是被适配类，鸭子是目标类
 *继承野火鸡类，实现鸭子接口
 */
public class TurkeyAdapter extends WildTurkey implements Duck {
    public void quack() {
        super.gobble();
    }

    public void fly(){
        super.fly();
        super.fly();
        super.fly();
    }
}

对象适配器和类适配器的差异

3. 从枚举器到迭代器的适配

从老版本的枚举器如何通过适配的方式升级到迭代器

通过对象适配器的形式，进行构建

public class EnumerationIterator implements Iterator<Object> {
    private Enumeration enumeration;

    public EnumerationIterator(Enumeration enumeration){
        this.enumeration = enumeration;
    }

    public boolean hasNext() {
        return enumeration.hasMoreElements();
    }

    public Object next() {
        return enumeration.nextElement();
    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
}