设计模式-适配器模式

定义：将一个类的接口转换成用户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的哪些类可以一起工作。

类图：

    

类适配器模式结构图

对象适配器模式结构图

说明：Target表示抽象目标类，它表示客户端需要使用的特定领域的接口，该接口不能随意改动；Adapter表示适配器类，它是适配器模式的核心，用于调用另一个接口，它作为一个转换器，对Adaptee接口和Target接口进行适配，如果是类适配器，Adapter实现了Target接口，并继承了Adaptee类，在实现Target接口的request()方法时可以直接调用从Adaptee类继承过来的specificRequest()方法；如果是对象适配器，Adapter继承了Target类且与Adaptee是关联关系，即在Adapter中定义了Adaptee对象，从而可调用在Adaptee中已实现的方法；Adaptee表示适配者类(被分配)，用于定义一个已经存在的接口，这个接口需要被适配；Client表示客户类，用于与符合Target接口的对象进行协同。

优点：

①更好的复用性，系统需要使用现有的类，而此类的接口不符合系统的需要。那么需要通过适配器模式就可以让这些功能得到更好的复用。

②更好的扩展性，在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。

缺点：

①过多的使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是A接口，其实内部被适配成了B接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不适用适配器，而是直接对系统进行重构。

适用环境：

①我们在使用第三方的类库，或者说第三方的API的时候，我们通过适配器转换来满足现有系统的使用需求。

②我们的旧系统与新系统进行集成的时候，我们发现旧系统的数据无法满足新系统的需求，那么这个时候，我们可能需要适配器，完成调用需求。

③我们在使用不同数据库之间进行数据同步。

实例场景：现有一个接口DataOperation定义了排序方法sort(int[])和查找方法search(int[],int),已知类QuickSort的quickSort(int[])方法实现了快速排序算法，类BinarySearch的binarySearch(int[],int)方法实现了二分查找算法。

实例类图：

           

实例代码：

//抽象数据操作类：

/**
 * 抽象数据操作类：目标接口
 * @author fly
 *
 */
interface DataOperation {

	public int[] sort(int[] array);
	public int search(int[] array,int key);
}

操作适配器类：

class OperationAdapter implements DataOperation{

	private QuickSort sortObj;
	private BinarySearch searchObj;
	
	public OperationAdapter(QuickSort sortObj,BinarySearch searchObj) {
		// TODO Auto-generated constructor stub
		this.sortObj = sortObj;
		this.searchObj = searchObj;
	}
	
	@Override
	public int[] sort(int[] array) {
		// TODO Auto-generated method stub
		return sortObj.quickSort(array);
	}

	@Override
	public int search(int[] array, int key) {
		// TODO Auto-generated method stub
		return searchObj.binarySearch(array, key);
	}
}

//适配者类：

/**
 * 快速排序类：适配者
 * @author fly
 *
 */
class QuickSort {

	public int[] quickSort(int[] array){
		sort(array,0,array.length-1);
		return array;
	}
	
	public void sort(int[] array,int p,int r){
		int q=0;
		if(p<r){
			q = partition(array,p,r);
			sort(array,p,q-1);
			sort(array,q+1,r);
		}
	}
	
	public int partition(int[] a,int p,int r){
		int x = a[r];
		int j = p -1;
		for (int i = p; i <=r-1; i++) {
			if(a[i]<=x){
				j++;
				swap(a,j,i);
			}
		}
		swap(a,j+1,r);
		return j+1;
	}
	
	public void swap(int[] a,int i,int j){
		int t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
}
/**
 * 二分查找类：适配者
 * @author fly
 *
 */
class BinarySearch {

	public int binarySearch(int[] array,int key){
		int low = 0;
		int high = array.length -1;
		while(low<=high){
			int mid = (low+high)/2;
			int midVal = array[mid];
			if(midVal<key){
				low = mid +1;
			}else if(midVal>key){
				high = mid - 1;
			}else{
				return 1;//找到元素返回1
			}
		}
		return -1;//未找到元素返回-1
	}
}

//客户端测试类：

/**
 * 客户端测试类
 * @author fly
 *
 */
class Client {

	public static void main(String[] args) {
		DataOperation operation;//针对抽象目标接口编程
		QuickSort sortObj = new QuickSort();
		BinarySearch searchObj = new BinarySearch();
		operation = new OperationAdapter(sortObj, searchObj);
		int[] array = {13,24,15,36,26,17,68,34};
		int result[];
		int value;
		
		System.out.println("排序结果：");
		result = operation.sort(array);
		for(int i:array){
			System.out.print(i+",");
		}
		System.out.println();
		
		System.out.println("查找关键字24：");
		value = operation.search(result, 24);
		if(value != -1){
			System.out.println("找到关键字24");
		}else{
			System.out.println("没有找到关键字24");
		}
		
		System.out.println("查找关键字25：");
		value = operation.search(result, 25);
		if(value != -1){
			System.out.println("找到关键字25");
		}else{
			System.out.println("没有找到关键字25");
		}
	}
}

//运行结果：