适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

主要解决：主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。

何时使用：

1、系统需要使用现有的类，而此类的接口不符合系统的需要。

2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。

3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）

如何解决：继承或依赖（推荐）。

关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。

优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。

缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。

注意事项：适配器不是在详细设计时添加的，而是解决正在服役的项目的问题。

适配器模式（Adapter）通常适用于以下场景：

1.以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。

2.使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

适配器模式（Adapter）包含以下主要角色：

目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。

适配者（Adaptee）类：需要适配的类或适配者类。

适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

实现：

（1）类的适配器模式（采用继承实现）

/**
 * 
 * @ClassName: Target
 * @Description: 目标接口，待适配
 * @author: ljx
 * @date: 2019年1月17日 下午1:56:21
 */
public interface Target {
	//新方法
	public void request();
	//已有方法
	public void request2();
}

/**
 * 
 * @ClassName: Adaptee
 * @Description: 适配者：已存在的、具有特殊功能、但不符合我们既有的标准接口的类
 * @author: ljx
 * @date: 2019年1月17日 下午2:02:08
 */
public class Adaptee {
	public void request2(){
		System.out.println("我是两孔插头,一直都有使用");
	}
}

/**
 * 
 * @ClassName: Adapter
 * @Description: 适配器类：继承了被适配类，同时实现标准接口
 * @author: ljx
 * @date: 2019年1月17日 下午2:04:06
 */
public class Adapter extends Adaptee implements Target{
	//实现目标接口
	@Override
	public void request() {
		System.out.println("我是三孔插头，在这里适配了。");
	}
	
}

/**
 * 
 * @ClassName: Test1
 * @Description: 测试
 * @author: ljx
 * @date: 2019年1月17日 下午2:06:52
 */
public class Test1 {

	public static void main(String[] args) {
		Target t = new Adapter();
		t.request();
		t.request2();
	}

}

结果：我是三孔插头，在这里适配了。

          我是两孔插头,一直都有使用

（2）对象的适配器模式（采用对象组合方式实现）

/**
 * 
 * @ClassName: Target
 * @Description: 目标接口，待适配
 * @author: ljx
 * @date: 2019年1月17日 下午1:56:21
 */
public interface Target {
	//新方法
	public void request();
	//已有方法
	public void request2();
}

/**
 * 
 * @ClassName: Adaptee
 * @Description: 适配者：已存在的、具有特殊功能、但不符合我们既有的标准接口的类
 * @author: ljx
 * @date: 2019年1月17日 下午2:02:08
 */
public class Adaptee {
	public void request2(){
		System.out.println("我是两孔插头,一直都有使用");
	}
}

/**
 * 
 * @ClassName: Adapter2
 * @Description: 适配器：直接关联被适配类，同时实现标准接口 （采用对象组合方式实现）
 * @author: ljx
 * @date: 2019年1月17日 下午2:19:03
 */
public class Adapter2 implements Target {
	
	private Adaptee adaptee;
	
	public Adapter2(Adaptee adaptee){
		this.adaptee = adaptee;
	}

	@Override
	public void request() {
		System.out.println("我是三孔插头，在这里适配了。");
	}

	@Override
	public void request2() {
		adaptee.request2();
	}

}

/**
 * 
 * @ClassName: Test2
 * @Description: 测试2
 * @author: ljx
 * @date: 2019年1月17日 下午2:22:09
 */
public class Test2 {
	public static void main(String[] args) {
		Adaptee adaptee = new Adaptee();
		Target target = new Adapter2(adaptee);
		target.request();
		target.request2();
	}
}

结果：我是三孔插头，在这里适配了。

          我是两孔插头,一直都有使用

（3）接口的适配器模式（缺省适配模式）：通俗点就是一个抽象类对功能接口的所有功能做空实现，然后子类继承这个抽象类，这样就可以对部分功能进行实现或拓展了

/**
 * 
 * @ClassName: SourceTarget
 * @Description: 源目标接口：所有方法
 * @author: ljx
 * @date: 2019年1月17日 下午2:34:46
 */
public interface SourceTarget {
	public void request1();
	public void request2();
}

/**
 * 
 * @ClassName: AbstractSourceTarget
 * @Description: 接口的适配器模式(缺省适配模式)，用来做空实现源目标接口
 * @author: ljx
 * @date: 2019年1月17日 下午2:44:22
 */
public abstract class AbstractAdapter implements SourceTarget {
        //空实现
	@Override
	public void request1() {}

	@Override
	public void request2() {}

}

/**
 * 
 * @ClassName: SourceSub1
 * @Description: 具体实现的类1
 * @author: ljx
 * @date: 2019年1月17日 下午2:50:54
 */
public class SourceSub1 extends AbstractAdapter{
	//重写实现方式
	public void request1(){
		System.out.println("我只需要三孔插头");
	}
}

/**
 * 
 * @ClassName: SourceSub2
 * @Description: 具体实现了2
 * @author: ljx
 * @date: 2019年1月17日 下午2:53:44
 */
public class SourceSub2 extends AbstractAdapter{
	//重写方法
	public void request2(){
		System.out.println("我只需要两孔插口");
	}
}

/**
 * 
 * @ClassName: Test3
 * @Description: 测试3
 * @author: ljx
 * @date: 2019年1月17日 下午2:54:41
 */
public class Test3 {
	public static void main(String[] args) {
		SourceTarget sub1 = new SourceSub1();
		SourceTarget sub2 = new SourceSub2();
		
		sub1.request1();
		sub1.request2();
		sub2.request1();
		sub2.request2();
	}
}

结果：我只需要三孔插头

           我只需要两孔插口

在任何时候，如果不准备实现一个接口的所有方法时，就可以使用“接口的适配器模式（缺省适配模式）”制造一个抽象类，给出所有方法的平庸的具体实现。这样，从这个抽象类再继承下去的子类就不必实现所有的方法了
 

......，欢迎指正！