设计模式之适配器模式

前言

     曾经有一份好的工作机会放在我的面前，可惜了是家外企，人家要求英语水平比较高，而自己的英语水平...，
  要多菜有多菜。我估计这是每一个想学好英语但是又实在是学不好英语的每个人的伤痛吧。现在全球化了之后，各国
  国家往来，每个国家的公民都可以到另外一个国家去旅游，但是又不是每个人都是精通多国语言的吧。由此就产生了
  翻译这个工作。中间找个人翻译，通过翻译就可以沟通了。当然如果翻译乱翻译...，那就没办法了。在java中，这
  种场景就是适配器的场景了，翻译代表了一个适配器。

结构图

代码实例

   当一个不懂英语CBA球员到NBA打球后，如果战术部署的时候听不懂教练的英语不就坑爹了，所以在教练和CBA球员
之间安排一个翻译的人，负责将教练的的战术翻译给CBA球员听，这样就解决了CBA球员听不懂教练战术部署的问题了。

/**
 * NBA球员接口类
 */
public interface NbaPlayer {

    //进攻
    public void attack();

    //防守
    public void guard();
}

/**
 * NBA球员A类
 */
public class NbaPlayerA implements NbaPlayer {

    private String name;

    public String getName() {
        return name;
    }

    public NbaPlayerA(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void attack() {
        System.out.println("球员A" + name + "进攻");
    }

    @Override
    public void guard() {
        System.out.println("球员A" + name + "防守");
    }
}

/**
 * NBA球员B类
 */
public class NbaPlayerB implements NbaPlayer {

    private String name;

    public String getName() {
        return name;
    }

    public NbaPlayerB(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void attack() {
        System.out.println("球员B" + name + " 进攻");
    }

    @Override
    public void guard() {
        System.out.println("球员B" + name + "防守");
    }
}


/**
 * NBA球员C类
 */
public class NbaPlayerC implements NbaPlayer {

    private String name;

    public String getName() {
        return name;
    }

    public NbaPlayerC(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void attack() {
        System.out.println("球员C" + name + "进攻！");
    }

    @Override
    public void guard() {
        System.out.println("球员C" + name + "防守！");
    }
}

/**
 * CBA球员
 */
public class CbaPlayer {
    private String name;

    public CbaPlayer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void cAttack(){
        System.out.println("CBA球员" + name + "进攻!");
    }

    public void cGuard(){
        System.out.println("CBA球员" + name + "防守!");
    }
}

/**
 * 适配器  翻译类
 */
public class Translation implements NbaPlayer{
    private CbaPlayer cbaPlayer;

    public Translation(String name) {
        this.cbaPlayer = new CbaPlayer(name);
    }

    @Override
    public void attack() {
        cbaPlayer.cAttack();
    }

    @Override
    public void guard() {
        cbaPlayer.cGuard();
    }
}

/**
 * 客户端测试类
 */
public class Main {

    public static void main(String[] args) {
        NbaPlayer nbaPlayerA = new NbaPlayerA("詹姆斯");
        nbaPlayerA.attack();
        nbaPlayerA.guard();
        NbaPlayer nbaPlayerB = new NbaPlayerB("加内特");
        nbaPlayerB.attack();
        nbaPlayerB.guard();
        NbaPlayer nbaPlayerC = new NbaPlayerC("科比");
        nbaPlayerC.attack();
        nbaPlayerC.guard();
        NbaPlayer translation = new Translation("姚明");
        translation.attack();
        translation.guard();
    }
}

输出结果

总结

 适配器模式：将目标类接口转化为客户端能够调用的接口，从而使得可以客户端调用目标接口。这样不必修改相关代码，
 只需要增加一个是适配器类即可。
 当一个类想调用另外一个类的一个接口或者方法的时候，发现和自己所期望的不一样，此时就可以在两者中间新增一个
 适配器类，让他来将两个接口匹配，从而可以实现调用。这样两个类之间还是没有耦合关系。