适配器模式

一.适配器模式：

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

二.场景

三.适配器模式中的三种角色：

①目标(Target):是一个接口，该接口是客户想使用的接口；
②被适配者(Adaptee):是一个已经存在的接口或抽象类，它需要被适配；
③适配器(Adapter):是一个类，实现了目标接口，并包含被适配者的引用。

四.适配器模式的实现方式：

1.类适配器模式（采用继承的方式实现）
2.对象适配器模式（采用对象组合的方式实现）

对象适配器UML图：

类适配模式UML图：

双向适配器UML图：

六.代码示例：

1.对象适配器：

被适配者（是一个已经存在的接口或抽象类，它需要被适配）：

/**   
 * @ClassName:  Bird   
 * @Description:被适配者接口   
 * @author: lsh
 * @date:   2019年5月31日    
 */
public interface Turkey {
    
    public void gobble();
    public void fly();
    
}

/**   
 * @ClassName:  TurkeyImpl   
 * @Description: 实现类  
 * @author: lsh
 * @date:   2019年5月31日    
 */
public class TurkeyImpl implements Turkey {

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

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

}

目标接口（是一个接口，该接口是客户想使用的接口）：

public interface Bird {

    public void quack();
    public void fly();
    
}

适配器类（是一个类，实现了目标接口，并包含被适配者的引用）：

/**   
 * @ClassName:  TurkeyAdapter   
 * @Description: 对象适配器：  火鸡对象冒充（适配）飞鸟对象
 * @author: lsh
 * @date:   2019年5月31日    
 */
public class TurkeyAdapter implements Bird {
    
    private Turkey turkey; // 被适配者引用
    
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }

    
    @Override
    public void quack() {
        turkey.gobble();
    }

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

测试：

public class AdapterTest {
    public static void main(String[] args) {
        // 火鸡冒充飞鸟
        Bird bird = new TurkeyAdapter(new TurkeyImpl());
        bird.quack();
        bird.fly();
    }
}

结果：

2.类适配器模式（保留上面的被适配者类和目标接口）：

适配器类：

/**   
 * @ClassName:  TurkeyClassAdapter   
 * @Description:类适配器（采用继承的方式）   
 * @author: lsh
 * @date:   2019年6月1日    
 */
public class TurkeyClassAdapter extends TurkeyImpl implements Bird {

    @Override
    public void quack() {
       super.gobble();
    }
    
    @Override
    public void fly() {
        super.fly();
    }

}

3.双向适配器模式：

/**   
 * @ClassName:  Bird   
 * @Description:被适配者接口   
 * @author: lsh
 * @date:   2019年5月31日    
 */
public interface Turkey {
    
    public void gobble();
    public void fly();
    
}

/**   
 * @ClassName:  TurkeyImpl   
 * @Description: 实现类  
 * @author: lsh
 * @date:   2019年5月31日    
 */
public class TurkeyImpl implements Turkey {

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

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

}

public interface Bird {

    public void quack();
    public void fly();
    
}


public class BirdImpl implements Bird {

    @Override
    public void quack() {
        System.out.println("Quack");
    }

    @Override
    public void fly() {
        System.out.println("I am flying");
    }

}

双向适配器类：

public class TrukeyAndBirdAdapter implements Bird, Turkey {
    
    private Turkey turkey;
    private Bird bird;
    
    public TrukeyAndBirdAdapter(Turkey turkey, Bird bird) {
        this.turkey = turkey;
        this.bird = bird;
    }
    
    @Override
    public void gobble() {
        bird.quack();
    }

    @Override
    public void quack() {
        turkey.gobble();
    }

    @Override
    public void fly() {
        
        if (this instanceof Bird) {
            for (int i = 0; i < 5; i++) 
                this.turkey.fly();
        }
        
        if (this instanceof Turkey) {
            this.bird.fly();
        }
        
    }

}

测试：

public class AdapterTest {
    public static void main(String[] args) {
        // 飞鸟火鸡相互冒充
        TrukeyAndBirdAdapter adapter = new TrukeyAndBirdAdapter(new TurkeyImpl(), new BirdImpl());
        Turkey turkey2 = adapter;
        System.out.println("飞鸟冒充火鸡");
        turkey2.fly();
        
        Bird bird2 = adapter;
        System.out.println("火鸡冒充飞鸟");
        bird2.fly();
    }
}

结果：

七》总结：

一.适配器模式的优点：
1：将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无需修改原有结构。
2：增加了类的透明性和复用性，将具体的业务实现过程封装在适配者类中，对于客户端类而言是透明的，而且提高了适配者的复用性，同一适配者类可以在多个不同的系统中复用。
3：灵活性和扩展性都非常好，通过使用配置文件，可以很方便的更换适配器，也可以在不修改原有代码的基础上 增加新的适配器，完全复合开闭原则。

二.缺点：
　1：一次最多只能适配一个适配者类，不能同时适配多个适配者。
　2：目标抽象类只能为接口，不能为类，其使用有一定的局限性。

三.适配器模式的适用环境：
1.系统需要使用一些现有的类，而这些类的接口不符合系统的需要，甚至没有这些类的源代码
2.创建一个可以重复使用的类，用于和一些彼此之间没有太大关联的类，包括一些可能在将来引进的类一起工作
3. 两个类所做的事情相同或相似，但是具有不同接口的时候。
4.旧的系统开发的类已经实现了一些功能，但是客户端却只能以另外接口的形式访问，但我们不希望手动更改原有类的时候。
5.使用第三方组件，组件接口定义和自己定义的不同，不希望修改自己的接口，但是要使用第三方组件接口的功能。