适配器模式

• 概述 : 将一个类的接口转换成另一个客户希望的接口.适配器模式使得原本由于接口不兼容而不能一起工作的类可以一起工作.
• 适配器模式的种类

• 类的适配器模式
• 对象的适配器模式
• 接口的适配器模式

• 涉及角色

• 目标(Target)角色 : 所期待得到的接口
• 源(Adapee)角色 : 现在需要适配的接口
• 适配器(Adaper)角色 : 适配器把源接口转换成目标接口

• 应用场景

• 类的适配器模式 : 系统需要使用现有的类,而此类的接口不符合系统的需要.这样就需要编写一个新的接口,创建一个适配器角色类,继承源角色类,实现新的接口即可.
• 对象的适配器模式 : 当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Adapter类,持有原类的一个实例,在Adapter类的方法中调用原类的方法即可.
• 接口的适配器模式 : 不希望实现一个接口中的所有方法时,可以创建一个抽象类AdpterSub,实现所有方法,使用接口中的某些方法时,只需要继承抽象类AdpterSub中那些方法,并重写就可以了.

类的适配器模式

• 场景 : Adapee类中method1待适配,目标接口为Target,使用适配类Adapter继承Adapee类实现将Adapee类中的method1方法扩展到目标接口中去.
• 类图

代码实现

源角色类

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class Adapee {
  public void method1(){
    System.out.println("待适配的方法");
  }
}

目标角色接口

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public interface Target {
  public void method1();
  public void method2();
}

适配器角色

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class Adapter extends Adapee implements Target {
  @Override
  public void method2() {
    System.out.println("实现Target接口的方法");
  }
}

测试方法

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class AdapterTest {
  public static void main(String[] args) {
    Target target = new Adapter();

    target.method1();

    target.method2();
  }
}

输出:

对象的适配器模式

• 场景 : 在不继承源角色类(Adapee)的情况下,将源角色类中的method1方法扩展到目标角色(Target)接口中去.
• 类图

代码实现

适配角色类代码 

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class Adapter implements Target {
  private Adapee adapee;

  public Adapter(Adapee adapeeTemp){
    this.adapee = adapeeTemp;
  }

  @Override
  public void method1() {
    adapee.method1();
  }

  @Override
  public void method2() {
    System.out.println("实现Target接口的方法");
  }
}

测试类

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class AdapterTest {
  public static void main(String[] args) {
    Target target = new Adapter(new Adapee());

    target.method1();

    target.method2();
  }
}

输出结果 : 

接口适配器模式

• 场景: 有时候我们抽象方法时,可能会在一个接口中抽象出多个方法,但是有些实现类并不需要该接口的全部的方法声明,如果将全部的声明方法全部实现的话,明显会很浪费.所以当我们需要某一个接口中的部分方法的时候,可以使用接口的适配器模式.
• 做法:在要实现的类与接口之间增加一个抽象类,由由抽象类实现接口.然后要实现的类不在实现接口,转而继承抽象类,这样就可以通过重写自己需要的方法来完成需求.
• 类图:

代码实现

需要实现的接口 

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public interface Adapee {
  public void method1();
  public void method2();
  public void method3();
}

抽象类

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public abstract class AdpterSub implements Adapee {
  public void method1(){

  }
  public void method2(){

  }
  public void method3(){

  }
}

适配类

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class Adapter extends AdpterSub{
  @Override
  public void method2() {
    System.out.println("需要重写的方法2");
  }

  @Override
  public void method3() {
    System.out.println("需要重写的方法3");
  }
}

测试类

package Adapter;

/**
 * Created by looper on 2017/8/15.
 */
public class AdapterTest {
  public static void main(String[] args) {
    Adapter adapter = new Adapter();
    adapter.method2();
    adapter.method3();
  }
}

输出结果:

设计模式只是一种思想,它是在某些方面上可以帮助设计者更好的架构整个代码结构,并不是每一个设计模式只能用在我上面提到的场景下,只要是能够运用某一个设计模式能够方便编码或者理解,都是可以理解为可以使用该设计模式的场景