# 前言
《Head First Design Patterns》给的代码的例子是关于鸭子和火鸡，然而鸭子和火鸡离日常生活比较远。这次，我改编了实验楼网站上面的例子，关于插座和充电器。
图：不同国家的插座，插头不一样，呵呵哒
图：所以需要写一个适配器模式
图：我绘制的适配器类图
情景：美国的插座，提供110伏电压；中国的插座，提供220伏电压。
1. 在中国，用两孔插座充电
1. 然后坐飞机去美国旅游，假设美国某旅馆的墙上有只有一个三孔插座
1. 幸好我有美国适配器，一头插到三孔插座，另一头转换成二孔插座，就可以给我的荣耀手机充电
1. 在美国，通过美国适配器，用三空插座充电
总共7个类
一个三孔插座接口（Adaptee, 被适配者）
一个三孔插座类
一个两孔插座接口（Target, 适配目标）
一个两孔插座类
一个适配器（Adapter：**实现Target, 组合Adaptee**）
一个手机类（Client）
一个Main类，用于测试
# talk is cheap, show me the code
### 三孔插座接口（Adaptee）
~~~
package adapter;
// adaptee(被适配者) ———— 假设在美国某旅馆的墙上，只有一个三孔插座
public interface ThreePinSoket
{
public void chargeWithThreePin();
public int voltage();
}
~~~
### 三孔插座类
~~~
package adapter;
// 实现一个具体的 adaptee
public class ThreePinSoketAmerica implements ThreePinSoket
{
@Override
public void chargeWithThreePin()
{
System.out.println("美国标准的三孔的插座");
}
@Override
public int voltage()
{
return 110; // 美国电压是110伏
}
}
~~~
### 两孔插座接口（Target）
~~~
package adapter;
// target(适配目标) ———— 我的荣耀手机充电器是两个插头，所以需要两个插孔的插座
public interface TwoPinSoket
{
public void chargeWithTwoPin();
public int voltage();
}
~~~
### 两孔插座类
~~~
package adapter;
// client(具体的adaptee) ———— 这个就是我在中国的墙上的两个插孔的插座，我充电只能用这个
public class TwoPinSoketChina implements TwoPinSoket
{
@Override
public void chargeWithTwoPin()
{
System.out.println("中国标准的两孔的插座");
}
@Override
public int voltage()
{
return 220; // 中国电压是220伏
}
}
~~~
### 适配器（Adapter)
**实现Target, 组合Adaptee**
~~~
package adapter;
// 去美国旅游，必须带上一个“美国适配器”：实现两孔插座，组合三孔插座。用来给我的荣耀手机充电
public class AmericaAdapter implements TwoPinSoket // 实现两孔插座(target)
{
ThreePinSoket threePinSoket; // 组合三孔插座(adaptee)
public AmericaAdapter(ThreePinSoket threePinSoket)
{
this.threePinSoket = threePinSoket;
}
@Override
public void chargeWithTwoPin()
{
threePinSoket.chargeWithThreePin();
}
@Override
public int voltage()
{
return threePinSoket.voltage() * 2; // 适配器把电压从 110V 升到 220V
}
}
~~~
### 手机类（Client）
~~~
package adapter;
public class RongYao
{
TwoPinSoket twoPinSoket;
public RongYao() {}
public void setTwoPinSoket(TwoPinSoket twoPinSoket)
{
this.twoPinSoket = twoPinSoket;
}
public void chargeRequest()
{
System.out.println("华为荣耀手机， " + twoPinSoket.voltage() + " 伏特充电中\n");
}
}
~~~
### Main类，用于测试
~~~
package adapter;
public class Main
{
public static void main(String[] args)
{
// 在中国，用两孔插座充电
TwoPinSoketChina twoPinSoketChina = new TwoPinSoketChina();
RongYao myRongYao = new RongYao();
myRongYao.setTwoPinSoket(twoPinSoketChina);
myRongYao.chargeRequest();
// 然后坐飞机去美国旅游，美国某旅馆的墙上有只有一个三孔插座
ThreePinSoketAmerica threePinSoketAmerica = new ThreePinSoketAmerica();
testThreePin(threePinSoketAmerica);
// 幸好我有美国适配器，一头插到三孔插座，另一头转换成二孔插座，就可以给我的荣耀手机充电
AmericaAdapter americaAdapter = new AmericaAdapter(threePinSoketAmerica);
testTwoPin(americaAdapter);
// 在美国，通过美国适配器，用三空插座充电
myRongYao.setTwoPinSoket(americaAdapter);
myRongYao.chargeRequest();
}
static void testTwoPin(TwoPinSoket twoPinSoket)
{
twoPinSoket.chargeWithTwoPin();
System.out.println("电压是" + twoPinSoket.voltage() + "伏特\n");
}
static void testThreePin(ThreePinSoket threePinSoket)
{
threePinSoket.chargeWithThreePin();
System.out.println("电压是" + threePinSoket.voltage() + "伏特\n");
}
}
~~~
# 运行结果
直接从eclipse复制过来
~~~
华为荣耀手机， 220 伏特充电中
美国标准的三孔的插座
电压是110伏特
美国标准的三孔的插座
电压是220伏特
华为荣耀手机， 220 伏特充电中
~~~
# 分析
适配器模式有三个重要角色：
- 目标角色（Target），要**转换成**的目标接口。在我的代码例子中，是中国的两孔接口
- 源角色（Adaptee），需要**被转换**的源接口。在我的代码例子中，是美国的三孔接口
- 适配器角色（Adapter），核心是**实现Target接口, 组合Adaptee接口**
这样，Adaptee和Target两个原本不兼容的接口，就可以在一起工作了（我的荣耀手机就可以在美国充电了）。这里的面向接口编程，得到了松耦合的效果。
美国的三孔插座可以实现Adaptee接口，那么英国、法国的三孔插座也可以去实现Adaptee接口，它们都成为了Adaptee接口的子类。在Adapter类中，由于组合了一个Adaptee的引用，根据Java的多态性，我就可以拿着相同的Adapter类去英国，法国充电了。
另一方面，Client类组合一个Target接口的引用。我们就可制造多个Adapter类，实现同一个Target接口。假设索尼手机的需要日本标准的两孔插座，那么写一个日本两孔插座类实现Target接口，我就可以拿着相同的Adapter类，在美国给日本的索尼手机充电了。
最后补充一点：《Head First Design Patterns》说到，适配器模式其实分为两种。一种是Object Adapter，另外一种是Class Adapter。本篇博客就是一个Object Adapter的例子。那么Class Adapter是长什么样子的呢？它**继承Adaptee类，实现Target接口** 。《设计模式 （Java版）》中的例子就是这样的。
[更多设计模式，在新标签页中打开这里~](http://blog.csdn.net/u013390476/article/details/50333763)
