适配器模式

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

主要解决：主要解决在软件系统中，常常要将一些”现存的对象”放到新的环境中，而新环境要求的接口是现对象不能满足的。

何时使用：
1、系统需要使用现有的类，而此类的接口不符合系统的需要。
2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。
3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）
如何解决：继承或依赖（推荐）。
关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。

理解：对象适配器，把被适配的类，放入适配器中成为属性
类适配器，继承被适配的类，让适配器获取其内部的方法。

代码：

Main

package adaptermodern;

import adaptermodern.adapter.TurkayAdapter;
import adaptermodern.adapter.TurkeyAdapter1;
import adaptermodern.duck.Duck;
import adaptermodern.duck.GreenHeadDuck;
import adaptermodern.turkey.WildTurkey;

public class MainTest {
    public static void main(String[] args) {
        //测试对象适配器（推荐）  将火鸡转换为鸭子类型 
        GreenHeadDuck greenHeadDuck = new GreenHeadDuck();
        greenHeadDuck.quack();
        greenHeadDuck.fly();

        WildTurkey wildTurkey = new WildTurkey();
        wildTurkey.gobble();
        wildTurkey.fly();

        Duck duck = new TurkayAdapter(wildTurkey); // 由于实现了Dusk的接口，可以向上转型为Dusk
        duck.quack();                               //用Dusk调用实现的方法
        duck.fly();

        System.out.println();
        //测试类适配器
        GreenHeadDuck greenHeadDuck1 = new GreenHeadDuck();
        greenHeadDuck1.quack();
        greenHeadDuck1.fly();

        WildTurkey wildTurkey1 = new WildTurkey();
        wildTurkey1.gobble();
        wildTurkey1.fly();
        Duck duck1 = new TurkeyAdapter1();           // 由于实现了Dusk的接口，可以向上转型为Dusk
        duck.quack();                                //用Dusk调用实现的方法
        duck.fly();

    }
}

Duck接口

package adaptermodern.duck;

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

实现Duck

package adaptermodern.duck;

public class GreenHeadDuck implements Duck {

    @Override
    public void quack() {
        System.out.println("GAGA~");

    }

    @Override
    public void fly() {
        System.out.println("I'm flying~~");

    }

}

Turkey接口

package adaptermodern.turkey;

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

实现Turkey

package adaptermodern.turkey;

public class WildTurkey implements Turkey{

    @Override
    public void gobble() {
        System.out.println("GOGOGO");

    }

    @Override
    public void fly() {
        System.out.println("I'm flying a short distance");

    }

}

对象适配器

package adaptermodern.adapter;

import adaptermodern.duck.Duck;
import adaptermodern.turkey.Turkey;

public class TurkayAdapter implements Duck{     //对象适配器   Duck是适配的目标 TurkayAdapter
                                                //是被适配的目标
    private Turkey turkey ;                     //使用火鸡类
    public TurkayAdapter(Turkey turkey){
        this.turkey = turkey ;
    }
    @Override
    public void quack() {
        turkey.gobble();                        //虽然模拟鸭子叫，但实际调用的是火鸡的方法

    }
    @Override
    public void fly() {
        turkey.fly();

    }


}

类适配器

package adaptermodern.adapter;

import adaptermodern.duck.Duck;
import adaptermodern.turkey.WildTurkey;

public class TurkeyAdapter1 extends WildTurkey implements Duck { //WildTurkey为被适配的类 
                                                                 //Duck为目标适配的类
    public void quack(){
        super.gobble();                     //原野生火鸡类的叫法
    }
    public void fly(){
        super.fly();                        //原野生火鸡类的叫法
    }

}