JAVA设计模式之适配器模式

一、适配器模式简介

Adapter模式也叫适配器模式，是构造型模式之一，通过Adapter模式可以改变已有类（或外部类）的接口形式。
从用户的角度看不到被适配者，是解耦的，用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法，用户收到反馈结果，感觉只是和目标接口交互。

二、适配器模式的结构

对象适配器

类适配器

三、适配器模式的具体实现

现在，不法商家想拿火鸡代替鸭子。
商家首先设计两个接口，鸭子和火鸡。

// An highlighted block
package design.adapter.gys.Duck;
public interface Duck {
 public void gaga();
 public void fly();
}

// An highlighted block
package design.adapter.gys.Turkey;
public interface Turkey {
 public void gaga();
 public void fly();
}

1、继承实现适配器（类适配器）

方案设计

类设计

接下来，商家实现红头火鸡和黑头鸭。

// An highlighted block
package design.adapter.gys.Turkey;
public class RedTurkey implements Turkey{
 @Override
 public void gaga() {
  // TODO Auto-generated method stub
  System.out.println("guagua");
 }
 @Override
 public void fly() {
  // TODO Auto-generated method stub
  System.out.println("i can fly one meter");
 }
}

// An highlighted block
package design.adapter.gys.Duck;
public class BlackDuck implements Duck{
 @Override
 public void gaga() {
  // TODO Auto-generated method stub
  System.out.println("gaga");
 }
 @Override
 public void fly() {
  // TODO Auto-generated method stub
  System.out.println("i can fly six meter");
 }
}

火鸡只会guagua叫，鸭子gaga叫。那么现在商家想用火鸡代替鸭子。定义一个类继承红头火鸡并实现鸭子的接口：

// An highlighted block
package design.adapter.gys.Duck;
import design.adapter.gys.Turkey.RedTurkey;
public class AdapterDuck2 extends RedTurkey implements Duck{
  public void gaga() {
   super.gaga();
  }
  public void fly() {
   super.fly();
   super.fly();
   super.fly();
   super.fly();
   super.fly();
   super.fly();
  }
}

来看看这个火鸡装的像不像：

// An highlighted block
package design.adapter.gys.adapter;
import design.adapter.gys.Duck.*;
import design.adapter.gys.Turkey.*;
public class Test {
 public static void main(String[] args) {
 AdapterDuck2 ad=new AdapterDuck2();
  ad.gaga();
  ad.fly();
 }
}

// An highlighted block
guagua
i can fly one meter
i can fly one meter
i can fly one meter
i can fly one meter
i can fly one meter
i can fly one meter

看来能瞒过消费者了，装的挺像。

2、委让实现适配器（对象适配器）

方案设计

类设计

设计一个包含了火鸡类域的鸭子类，在实现抽象方法的时候调用传入的火鸡参数的相应方法：

// An highlighted block
package design.adapter.gys.Duck;
import design.adapter.gys.Turkey.Turkey;
public class AdapterDuck implements Duck{
 private Turkey turkey;
 @Override
 public void gaga() {
  // TODO Auto-generated method stub
  turkey.gaga();
 }
 public AdapterDuck(Turkey turkey) {
  super();
  this.turkey = turkey;
 }
 @Override
 public void fly() {
  // TODO Auto-generated method stub
  turkey.fly();
  turkey.fly();
  turkey.fly();
  turkey.fly();
  turkey.fly();
  turkey.fly();
 }
}

接下来测试这只假鸭子：

// An highlighted block
package design.adapter.gys.adapter;
import design.adapter.gys.Duck.*;
import design.adapter.gys.Turkey.*;
public class Test {
 public static void main(String[] args) {
 AdapterDuck what=new AdapterDuck(new RedTurkey());
  what.gaga();
  what.fly();
  }
 }

// An highlighted block
guagua
i can fly one meter
i can fly one meter
i can fly one meter
i can fly one meter
i can fly one meter
i can fly one meter

这次装的也挺像的。

3、实现枚举器到迭代器的适配

早期的jdk中，使用的是枚举器，新的jdk中多数使用迭代器，我们在和老代码进行交互时，需要考虑兼容性问题，所以，我么来做一个适配器。

// An highlighted block
package design.adapter.gys.adapter;
import java.util.Enumeration;
import java.util.Iterator;
public class EnumToIterator<E>  implements Iterator<E>{
 private Enumeration<E> enu;
 @Override
 public boolean hasNext() {
  // TODO Auto-generated method stub
  return enu.hasMoreElements();
 }
 @Override
 public E next() {
  // TODO Auto-generated method stub
  return (E) enu.nextElement();
 }
 public void remove() {
  throw new UnsupportedOperationException();
 } 
}

由于枚举类中没有实现remove()方法，所以在调用时，我们抛出一个异常。

四、适配器模式的应用场景

在大规模的系统开发过程中，我们常常碰到诸如以下这些情况：
我们需要实现某些功能，这些功能已有还不太成熟的一个或多个外部组件，如果我们自己重新开发这些功能会花费大量时间；所以很多情况下会选择先暂时使用外部组件，以后再考虑随时替换。但这样一来，会带来一个问题，随着对外部组件库的替换，可能需要对引用该外部组件的源代码进行大面积的修改，因此也极可能引入新的问题等等。如何最大限度的降低修改面呢？
Adapter模式就是针对这种类似需求而提出来的。
Adapter模式通过定义一个新的接口（对要实现的功能加以抽象），和一个实现该接口的Adapter（适配器）类来透明地调用外部组件。这样替换外部组件时，最多只要修改几个Adapter类就可以了，其他源代码都不会受到影响。

要抱抱才会开心啊~~~~~~~~~~~~