结构型-适配器模式

结构型-适配器模式

定义：

适配器模式可以将一个类的接口，转换成客户端期望的另一个接口，让两个原本不兼容的接口/类可以无缝对接。

适配器模式的结构：

• 类适配器模式
• 对象适配器模式

第一种类适配器模式

类的适配器模式把适配的类的API转换成为目标类的API。

模式所涉及的角色：

• 目标(Target)角色：这就是所期待得到的接口。注意：由于这里讨论的是类适配器模式，因此目标不可以是类。
• 源(Adapee)角色：现在需要适配的接口。
• 适配器(Adaper)角色：适配器是本模式的核心。适配器把接口转换成目标接口，显然，这一角色不可以是接口，而必须是类。

/**
*目标(Target)角色
*/
public interface Target{
    //这是源类Adaptee也有的方法
    public void sampleOperation1()
    //这是源类Adaptee没有的方法
    public void sampleOperation2()
}
/**
*　源(Adapee)角色
*/
public class Adaptee{
    public void sampleOperation1()
}
/**
*　适配器(Adaper)角色
*/
public class Adapter extends Adaptee implements Target{
/**
 *由于源类Adaptee没有方法sampleOperation2，因此适配器需补充上这个方法
 */
    @Override
   public void sampleOperation2(){
       
   }
}

对象适配器模式

与类的适配器模式一样，对象的适配器把适配的类的API转换为目标类的API，与类的适配器模式不同的是，对象的适配器模式不是使用继承关系连接到Adaptee类，而是使用委派关系连接到Adaptee类（相当于包装了一个Adaptee实例）。

public interface Target{
    //这是源类Adaptee也有的方法
    public void sampleOperation1();
    //这是源类Adaptee没有的方法
    public void sampleOperation2();
}

public class Adaptee{
    public void sampleOperation1(){}
}

public class Adapter{
    private Adaptee adaptee;
    
    public Adapter(Adaptee adaptee){
        this.adaptee = adaptee;
    }
    //源类Adaptee有该方法，因此适配器直接委派即可
    public void sampleOperation1(){
        this.adaptee.sampleOperation1();
    }
    //源类Adaptee没有该方法，因此需要适配器补充此方法。
    public void sampleOperation2(){
        //写相关的代码
    }
}

类适配器与对象适配器对比：

• 类适配器使用对象继承的方式，是静态的定义方式；

  对象适配器使用对象组合的方式，是动态组合的方式。

• 类适配器，由于适配器直接继承了Adaptee,使得适配器不能和Adaptee的子类一起工作，因为继承是静态的关系，当适配器继承了Adaptee后，就不可能再去处理Adpatee的子类了。

  对象适配器，一个适配器可以把多种不同的源适配到同一个目标。也就是说，同一个适配器可以把源类和它的子类，都是适配到目标接口。因为对象适配器采用的是对象组合的关系，只要对象那个类型正确，是不是子类都无所谓。

• 类适配器，适配器合一重定义Apdatee的部分行为，相对于子类覆盖父类的实现方法。

  对象适配器，要重新定义Adaptee的行为比较困难，这种情况下，需要定义Adaptee的子类来实现重定义，然后让适配器组合子类

• 类适配器，仅仅引入了一个对象，并不需要额外的引用来间接得到Adaptee。

  对象适配器，需要额外的引用来间接得到Adaptee。

适配器模式的优缺点：

• 更好的复用性

  系统需要使用现有的类，而此类的接口不符合系统的需要，那明天通过适配器模式就可以让这些功能得到更好的复用。

• 更好的扩展性

  在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。

适配器模式的缺点

过多的使用适配器，会让系统非常的凌乱，不易整体进行把握。

比如，明明看到调用的是A接口，其实内部被适配成了B接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不适用适配器，而是直接对系统进行重构。

扩展：

缺省适配器

缺省适配器模式为一个接口提供缺省实现，这样子类型可以从这缺省实现进行扩展，而不必从原有接口进行扩展。

比如说，目标接口有7个方法，而我只需要使用其中的两个，其他5个都是我不需要的，我们就可以使用“缺省适配模式”，制造一个抽象类，给出所有方法平庸的具体实现，这样，从这个抽象类再继承下去的子类就不必实现所有的方法了。

伪代码实现：

interface Target{
方法1（）
方法2（）
方法3（）
方法4（）
}
class ServiceAdapter implements Target{
方法1（）{}
方法2（）{}
方法3（）{}
方法4（）{}
}
class Adapter extends ServiceAdapter{
//只实现你所需要的方法即可。
方法4（）{}
}