结合案例深入解析适配器模式（一）

一、基本概念

将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

可以将适配器理解为我们日常用的电脑充电器: 家庭电压为220v，而电脑充电频率是20v左右，所以需要适配。

二、结构

适配器可以分为两种: 对象适配器和类适配器。

对象适配器:

 

 

从用户的角度看不到被适配者。

用户调用适配器转换出来的目标接口方法。适配器再调用被适配者的相关接口方法。

用户收到反馈结果，感觉只是和目标接口交互。

类适配器:

通过多重继承目标接口和被适配者类方式来实现适配。

三、案例

案例: 将火鸡冒充成鸭子。

1、对象适配器模式

逻辑图:

 

 

 

代码组织结构图:

 

 

 

被适配者火鸡turkey:

public interface turkey {
    void gobble(); // 火鸡叫声
    void fly();
}
/** 野火鸡 */
public class wildturkey implements turkey{
    @override
    public void gobble() {
        system.out.println("go go!");
    }

    @override
    public void fly() {
        system.out.println("i am flying a short distance!");
    }
}

 

目标对象duck:

/** 鸭子的接口 */
public interface duck {
    void quack();//鸭子叫声
    void fly();
}

 

适配器turkeyadapter:

/**
 * 在外面表现是 鸭子(目标)，但是实质是火鸡(被适配者)
 */
public class turkeyadapter implements duck { //实现目标的接口

    private turkey turkey; //这种对象型适配器必须要组合  被适配者，也就是要有适配者的引用

    public turkeyadapter(turkey turkey) {
        this.turkey = turkey;
    }

    // 实际是火鸡在叫
    @override
    public void quack() {
        turkey.gobble();//外面表现是quack,但是内部是turkey.gobble()
    }

    @override
    public void fly() {
        //由于火鸡飞的短，所以多飞几次，让火鸡更像鸭子
        for(int i = 0; i < 6; i++){
            turkey.fly();
        }
    }
}

 

测试:

public class mytest {

    public static void main(string[] args) {
        wildturkey turkey = new wildturkey();
        duck duck = new turkeyadapter(turkey);
        duck.quack(); //看似是鸭子，其实内置是火鸡
        duck.fly();
    }
}

 

输出:

go go!
i am flying a short distance!
i am flying a short distance!
i am flying a short distance!
i am flying a short distance!
i am flying a short distance!
i am flying a short distance!

 

2、类适配器模式

基本结构图:

 

 

 

虽然java不支持多继承，但是可以实现的同时继承。

只有turkeyadapter有一些代码变动，其他不变:

/**
 * 和 对象适配器模式唯一的不同就是  : 适配器直接继承 被适配者 (而不是组合)
 */
public class turkeyadapter extends wildturkey implements  duck {

    @override
    public void quack() {
        super.gobble(); //直接继承 被适配者
    }

    @override
    public void fly() {
        //让火鸡飞6次，飞的像鸭子
        super.fly();
        super.fly();
        super.fly();
        super.fly();
        super.fly();
        super.fly();
    }
}

 

测试:

public class mytest {

    public static void main(string[] args) {
        turkeyadapter duck = new turkeyadapter();//直接new即可
        duck.quack();
        duck.fly();
    }
}

 

输出和上面对象适配器一样。

3、java中从以前枚举器enumeration到迭代器iterator的适配

从enumeration到iterator适配的结构图:

 

 

 

一个实例代码:(下面enumerationiterator就是一个适配器)

/** 对象适配器的举例 java中的枚举到迭代器 */
public class enumerationiterator implements iterator<object> {
    private enumeration enumeration; //枚举 : 被适配者

    public enumerationiterator(enumeration enumeration) {
        this.enumeration = enumeration;
    }

    @override
    public boolean hasnext() {
        return enumeration.hasmoreelements(); //实际调用的是 被适配者 的方法
    }

    @override
    public object next() {
        return enumeration.nextelement();
    }

    //这个可以说是适配器的缺点， 有些不能适配，比如两个插孔的插头不能适配为三个插孔的插头
    @override
    public void remove() {
        throw new unsupportedoperationexception();
    }
}

 

四、总结

对象适配器和类适配器使用了不同的方法实现适配，对象适配器使用组合，类适配器使用继承。

 

免费java高级资料需要自己领取，涵盖了java、redis、mongodb、mysql、zookeeper、spring cloud、dubbo高并发分布式等教程，一共30g。
传送门：https://mp.weixin.qq.com/s/jzddfh-7ynudmkjt0irl8q