* 24种设计模式——适配器模式

核心：将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

[b]适配器可方便完成系统对接，实际系统中只是增加了一个业务类的继承，就实现 了可以查本公司的员工信息，也可以查到人力资源公司的员工信息。
[/b]

[b]适配器模式是解决正在服役的项目问题，是一种补救模式，主要场景是扩展应用，没有设计师在设计阶段考虑适配器。一般“对象适配器模式”比“类适配器模式”用的更多
[/b]

一、实现公司模块和外包模块之间的连接

                     




1. 员工信息接口

public interface IUserInfo {
//获得用户姓名
public String getUserName();
//获得家庭地址
public String getHomeAddress();
//手机号码
public String getMobileNumber();
//办公电话
public String getOfficeTelNumber();
//这个人的职责是什么
public String getJobPosition();
//获得家庭电话
public String getHomeTelNumber();
}

2. 实现类

public class UserInfo implements IUserInfo{
public String getUserName() {
System.out.println("姓名叫做...");
return null;
}
public String getHomeAddress() {
System.out.println("这里是员工的家庭地址...");
return null;
}
public String getMobileNumber() {
System.out.println("这个人的手机号码是0000...");
return null;
}
public String getOfficeTelNumber() {
System.out.println("办公室电话是...");
return null;
}
public String getJobPosition() {
System.out.println("这个人的职位是BOSS...");
return null;
}
public String getHomeTelNumber() {
System.out.println("这里是员工的家庭电话....");
return null;
}
}

3. 劳动服务公司的人员信息接口

public interface IOuterUser {
//基本信息、比如名称、性别、手机号码等
public Map getUserBaseInfo();
//工作区域信息
public Map getUserOfficeInfo();
//用户的家庭信息
public Map getUserHomeInfo();
}

4. 劳动服务公司的人员实现

public class OuterUser implements IOuterUser{
//用户的基本信息
public Map getUserBaseInfo() {
Map baseInfoMap = new HashMap();
baseInfoMap.put("userName", "这个员工叫混世魔王...");
baseInfoMap.put("mobileNumber", "这个员工电话是...");
return baseInfoMap;
}
//员工的工作信息
public Map getUserOfficeInfo() {
Map officeInfo = new HashMap();
officeInfo.put("jobPosition", "这个职位是BOSS...");
officeInfo.put("officeTelNumber", "员工的办公电话是...");
return officeInfo;
}
//员工的家庭信息
public Map getUserHomeInfo() {
Map homeInfo = new HashMap();
homeInfo.put("homeTelNumber", "员工的家庭电话是...");
homeInfo.put("homeAddress", "员工的家庭地址是...");
return homeInfo;
}
}

5. 中转角色

public class OuterUserInfo extends OuterUser implements IUserInfo{
private Map baseInfo = super.getUserBaseInfo();//员工的基本信息
private Map homeInfo = super.getUserOfficeInfo();//员工的家庭信息
private Map officeInfo = super.getUserHomeInfo();//工作信息
/*
* 用户姓名
*/
public String getUserName() {
String userName = (String) this.baseInfo.get("userName");
System.out.println(userName);
return userName;
}
/*
* 家庭地址
*/
public String getHomeAddress() {
String homeAddress = (String) this.homeInfo.get("homeAddress");
System.out.println(homeAddress);
return homeAddress;
}
/*
* 移动电话
*/
public String getMobileNumber() {
String mobileNumber = (String) this.baseInfo.get("mobileNumber");
System.out.println(mobileNumber);
return mobileNumber;
}
/*
* 办公电话
*/
public String getOfficeTelNumber() {
String officeTelNumber = (String) this.officeInfo.get("officeTelNumber");
System.out.println(officeTelNumber);
return officeTelNumber;
}
/*
* 职位
*/
public String getJobPosition() {
String jobPosition = (String) this.officeInfo.get("jobPosition");
System.out.println(jobPosition);
return jobPosition;
}
/*
* 家庭电话
*/
public String getHomeTelNumber() {
String homeTelNumber = (String) this.homeInfo.get("homeTelNumber");
System.out.println(homeTelNumber);
return homeTelNumber;
}
}

6. 场景类

public class Client {
public static void main(String[] args) {
//没有与外系统连接时
IUserInfo girl = new UserInfo();
//从数据库中查到101个美女电话
for(int i = 0;i < 101;i++){
girl.getMobileNumber();
}

//兔子不吃窝边草，
//与外系统连接时，查到101个美女电话
IUserInfo girlOuter = new OuterUserInfo();
for(int i = 0;i < 101;i++){
girlOuter.getMobileNumber();
}
}
}

适配器可方便完成系统对接，实际系统中只是增加了一个业务类的继承，就实现 了可以查本公司的员工信息，也可以查到人力资源公司的员工信息。

二、适配器模式的定义
将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。

                                             


Target目标角色：该角色定义把其他类转换为何种接口，也就是我们的期望接口，目标角色是一个正在运行的角色，不可能修改其源码，一般目标角色是接口或抽象类，不会是实现类，例子中的IUserInfo接口就是目标角色。

Adaptee源角色：你想把谁转换成目标角色，这个“谁”就是源角色。

Adapter适配器角色：适配器角色是需要新建立的，它的职责：把源角色转换为目标角色，通过继承或是类关联的方式。

1. 目标角色

public interface Target {
//目标角色有自己的方法
public void request();
}

2. 目标角色的实现类

public class ConcreteTarget implements Target{
public void request() {
System.out.println("if you need any help,pls call me!");
}
}

3. 源角色

public class Adaptee {
//原有的业务逻辑
public void doSomething(){
System.out.println("I'm kind of busy,leave me alone,pls!");
}
}

4. 适配器角色

public class Adapter extends Adaptee implements Target{
public void request() {
super.doSomething();
}
}

5. 场景类

public class Client {
public static void main(String[] args) {
//原有的业务逻辑
Target target = new ConcreteTarget();
target.request();
//现在增加了适配器角色后的业务逻辑
Target target2 = new Adapter();
target2.request();
}
}

三、适配器的应用

1. 优点

可以让两个没有任何关系的类在一起运行

增加了类的透明性，访问的Target目标角色，但是具
4000
体的实现都委托给了源角色，机电这些对高层次模块是透明的，也是它不需要关心的。

2. 使用场景

记住一点：你有动机修改一个已经投产中的接口时，适配器模式可能 最适合你的模式，比如：系统扩展了，需要使用一个已有或新建立的类，但这个类又不符合系统接口，这里可以使用适配器模式。

适配器模式是解决正在服役的项目问题，主要场景是扩展应用，没有设计师在设计阶段考虑适配器。

四、扩展（对象适配器模式）

如上例子，如果劳动服务公司提供的人员接口不止一个，也就是说，用户基本信息是一个接口，工作信息是一个接口，家庭信息是一个接口。这时我们的OuterUserInfo就不可能继承三个实现类，这时就不能用继承了，可以用类关联的办法。