适配器

把一个类接口转换成另一个用户需要的接口。

一、笔记本通过SD读卡去读取TF卡

①、先模拟计算机读取SD卡：

1、先创建一个SD卡的接口：

public interface SDCard {
    /*读取SD卡方法*/
    String readSD();
    /*写入SD卡功能*/
    int writeSD(String msg);
}

2、创建SD卡接口的实现类，模拟SD卡的功能：

public class SDCardImpl implements SDCard {
    @Override
    public String readSD() {
        String msg = "SD card read a msg :hello word SD";
        return msg;
    }
    @Override
    public int writeSD(String msg) {
        System.out.println("SD card write msg : " + msg);
        return 1;
    }
}

3、创建计算机接口，计算机提供读取SD卡方法：

public interface Computer {
    String readSD(SDCard sdCard);
}

4、创建一个计算机实例，实现计算机接口，并实现其读取SD卡方法：

public class ThinkpadComputer implements Computer {
    @Override
    public String readSD(SDCard sdCard) {
        if (sdCard == null) {
            throw new NullPointerException("sd card null");
        }
        return sdCard.readSD();
    }
}

5、模拟计算机读取SD卡功能：

public class Client {
    public static void main(String[] args) {
        SDCard sdCard = new SDCardImpl();
        Computer computer = new ThinkpadComputer();
        String msg = computer.readSD(sdCard);
        System.out.println("msg = " + msg);
    }
}

输出如下：

msg = SD card read a msg :hello word SD

②、接下来在不改变计算机读取SD卡接口的情况下，通过适配器模式读取TF卡：

1、创建TF卡接口：

public interface TFCard {
    /*读取TF卡方法*/
    String readTF();
    /*写入TF卡功能*/
    int writeTF(String msg);
}

2、创建TF卡实例：创建TF卡接口的实现类，模拟TF卡的功能：

public class TFCardImpl implements TFCard {
    @Override
    public String readTF() {
        String msg = "TF card reade msg : hello word tf card";
        return msg;
    }
    @Override
    public int writeTF(String msg) {
        System.out.println("TF card write a msg : " + msg);
        return 1;
    }
}

3、创建SD适配TF （也可以说是SD兼容TF，相当于读卡器），实现SDCard接口，并将要适配的对象作为适配器的属性引入。具体如下：

public class SDAdapterTF implements SDCard {
    private TFCard tfCard;
    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }
    @Override
    public String readSD() {
        System.out.println("adapter read TF card ......");
        return tfCard.readTF();
    }
    @Override
    public int writeSD(String msg) {
        System.out.println("adapter write TF card ......");
        return tfCard.writeTF(msg);
    }
}

4、测试计算机通过SD读卡器读取TF卡：

public class Client {
    public static void main(String[] args) {
        TFCard tfCard = new TFCardImpl();
        SDAdapterTF adapter = new SDAdapterTF(tfCard);
        Computer computer = new ThinkpadComputer();
        computer.readSD(adapter);
    }
}

输出如下：

adapter read TF card ......

二、使用适配器模式，将火鸡冒充鸭子

鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。

要求：将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！

1、先创建一个Duck接口：

/**
 * 鸭子
 */
public interface Duck {
    /*嘎嘎叫*/
    void quack();
}

2、先创建一个Turkey接口：

/**
 * 火鸡
 */
public interface Turkey {
    /*咯咯叫*/
    void gobble();
}

3、创建Turkey接口的实现类，模拟Turkey的功能：

public class WildTurkey implements Turkey{
    @Override
    public void gobble() {
        System.out.println("gobble......");
    }
}

3、创建Duck适配Turkey （也可以说是Duck兼容Turkey，相当于让火鸡冒充鸭子），实现Duck接口，并将要适配的对象作为适配器的属性引入。具体如下：

要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack()方法，从而让火鸡冒充鸭子！

public class DuckAdapterTurkey implements Duck {
    private Turkey turkey;
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }
    @Override
    public void quack() {
        turkey.gobble();
    }
}

4、测试通过DuckAdapterTurkey适配器，让火鸡冒充鸭子：

public class Client {
    public static void main(String[] args) {
        Turkey turkey = new WildTurkey();
        DuckAdapterTurkey adapter = new DuckAdapterTurkey(turkey);
        adapter.quack();
    }
}

输出如下：

gobble......