适配器模式（Adapter Pattern）

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

 有一个鸭子接口：

public interface Duck {
    public void quack();
    public void fly();
}

绿头鸭是鸭子的子类：

public class MallardDuck implements Duck {
    public void quack() {
        System.out.println("Quack");
     }
        
    public void fly() {
        System.out.println("I'm flying");
    }
}

有一个火鸡接口，不会呱呱叫，只会咯咯叫，与鸭子的不同，没有quack()，而是gobble()：

public interface Turkey {
    public void gobble();
    public void fly();
}

一个野生的火鸡，实现火鸡接口：

public class WildTurkey implements Turkey {
    public void gobble() {
        System.out.println("Gobble gobble");
    }
    public void fly() {
        System.out.println("I'm flying a short distance");
     }
}

如何用火鸡冒充鸭子而客户不知道呢？

我们写个适配器，实现鸭子的接口，实际上它使用的是火鸡

public class TurkeyAdapter implements Duck {
    Turkey turkey;
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }
    public void quack() {
        turkey.gobble();
    }
    public void () {
        turkey.fly();
    }
}

适配器传入一个火鸡实例，调用quack方法时，实际是调用gobble方法。

public DuckTest {
       public static void main(String[] args) {
            MallarDuck duck = new MallarDuck();
            
            WildTurkey turkey = new WildTurkey();
            Duck turkeyAdapter = new TurkeyAdapter(turkey);

            duck.quack();
            duck.fly();
            
            turkeyAdapter.quack();   
            turkeyAdapter.fly();
       }
}

通过适配器，火鸡成功冒充了鸭子，对客户来说一样调用了鸭子的quack和fly方法，gobble方法对客户不可见。

这种适配器称为对象适配器。

鸭子接口相当于Target，TurkeyAdapter相当于Adapter，Turkey相当于Adaptee。

假如我们没有Duck接口，只有MallardDuck类，那么就要Adapter继承MallardDuck类，其他都是一样的，这就变成了类适配器。

假如我们的Duck接口含有fly方法是Turkey没有的，我们不想重写这个方法，那么就写一个抽象的Adapter，Turkey继承这个Adapter，那就只需要重写quck方法，这就是接口适配器。