structure：适配器模式 （Adapter Pattern

定义：
将一个类的接口，转换成客户期望的另一个接口。
适配器让原本不兼容的类可以相互合作。
适配器可以是双向的。
如果目标接口比较多，则需要实现很多的转换工作。
通常一个适配器只包装一个被适配者，但如果需要包装多个被适配者，则变成了外观模式。

实现思路：
适配器实现目标接口，内部包含一个被适配者的引用。

实现：

package Adapter;

public interface Chick {
    public String shortFly();
    public String guuguu();
}

package Adapter;

public class ChickAdapter implements Duck {
    Chick chick;

    public ChickAdapter(Chick chick) {
        this.chick = chick;
    }

    @Override
    public String fly() {
       String fly=new String();
       for(int i=0;i<5;i++){
           fly=fly+ chick.shortFly();
       }
       System.out.println(fly);
       return fly;
    }

    @Override
    public String gaga() {
        System.out.println(chick.guuguu());
        return chick.guuguu();
    }
}

package Adapter;

public interface Duck {
    public String fly();
    public String gaga();
}

package Adapter;

public class DuckAdapter implements Chick {
    Duck duck;

    public DuckAdapter(Duck duck) {
        this.duck = duck;
    }

    @Override
    public String shortFly() {
       String fly=new String();
       fly=duck.fly().substring(0,duck.fly().length()/2);
       System.out.println(fly);
       return fly;
    }

    @Override
    public String guuguu() {
        System.out.println(duck.gaga());
        return duck.gaga();
    }
}

package Adapter;

public class TestAdapter {
    public static void test(){
        ChickAdapter chickAdapter=new ChickAdapter(new WildChick());
        chickAdapter.fly();
        chickAdapter.gaga();

    }
}

package Adapter;

public class WildChick implements Chick {
    @Override
    public String shortFly() {
        return " can fly a short distance ";
    }

    @Override
    public String guuguu() {
        return "guu guu guu!";
    }
}

package Adapter;

public class WildDuck implements Duck {

    @Override
    public String fly() {
        return "duck can fly";
    }

    @Override
    public String gaga() {
        return "ga ga ga!";
    }
}