适配器模式

概念：将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。
也就是原有的接口或者类满足不了新的功能需求，但是不能改动原有的代码，只能在原有的基础上进行拓展，而这时候就需要适配器的进入。
适配器的种类
类适配器模式和对象适配器模式最大的区别在于适配器和适配者之间的关系不同，对象适配器模式中适配器和适配者之间是关联关系，而类适配器模式中适配器和适配者是继承关系
对象适配器： 对适配者的引入（包含）
在适配器模式中引入了一个被称为适配器(Adapter)的包装类，而它所包装的对象称为适配者(Adaptee)，即被适配的类。适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用。也就是说：当客户类调用适配器的方法时，在适配器类的内部将调用适配者类的方法，而这个过程对客户类是透明的，客户类并不直接访问适配者类。因此，适配器让那些由于接口不兼容而不能交互的类可以一起工作。
综上所述：建立一个新的接口去包装原来的接口，进而兼容新的功能需求。

//抽象成绩操作类：目标接口
interface ScoreOperation {
	public int[] sort(int array[]); //成绩排序
	public int search(int array[],int key); //成绩查找
}
 
//快速排序类：适配者
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;   
	}
}
 
//二分查找类：适配者
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
	}
}
 
//操作适配器：适配器
class OperationAdapter implements ScoreOperation {
	private QuickSort sortObj; //定义适配者QuickSort对象
	private BinarySearch searchObj; //定义适配者BinarySearch对象
 
	public OperationAdapter() {
		sortObj = new QuickSort();
		searchObj = new BinarySearch();
	}
 
	public int[] sort(int array[]) {  
return sortObj.quickSort(array); //调用适配者类QuickSort的排序方法
}
 
	public int search(int array[],int key) {  
return searchObj.binarySearch(array,key); //调用适配者类BinarySearch的查找方法
}
}
       为了让系统具备良好的灵活性和可扩展性，我们引入了工具类XMLUtil和配置文件，其中，XMLUtil类的代码如下所示：

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
class XMLUtil {
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
	public static Object getBean() {
		try {
			//创建文档对象
			DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder = dFactory.newDocumentBuilder();
			Document doc;							
			doc = builder.parse(new File("config.xml")); 
		
			//获取包含类名的文本节点
			NodeList nl = doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName=classNode.getNodeValue();
            
            //通过类名生成实例对象并将其返回
            Class c=Class.forName(cName);
	  	    Object obj=c.newInstance();
            return obj;
        }   
        catch(Exception e) {
           	e.printStackTrace();
           	return null;
       	}
	}
}
       配置文件config.xml中存储了适配器类的类名，代码如下所示：

<?xml version="1.0"?>
<config>
	<className>OperationAdapter</className>
</config>
       编写如下客户端测试代码：

class Client {
	public static void main(String args[]) {
		ScoreOperation operation;  //针对抽象目标接口编程
		operation = (ScoreOperation)XMLUtil.getBean(); //读取配置文件，反射生成对象
		int scores[] = {84,76,50,69,90,91,88,96}; //定义成绩数组
		int result[];
		int score;
		
		System.out.println("成绩排序结果：");
		result = operation.sort(scores);
 
        //遍历输出成绩
		for(int i : scores) {
			System.out.print(i + ",");
		}
		System.out.println();
		
		System.out.println("查找成绩90：");
		score = operation.search(result,90);
		if (score != -1) {
			System.out.println("找到成绩90。");
		}
		else {
			System.out.println("没有找到成绩90。");
		}
		
		System.out.println("查找成绩92：");
		score = operation.search(result,92);
		if (score != -1) {
			System.out.println("找到成绩92。");
		}
		else {
			System.out.println("没有找到成绩92。");
		}
	}
}

    编译并运行程序，输出结果如下：
	成绩排序结果：
	50,69,76,84,88,90,91,96,
	查找成绩90：
	找到成绩90。
	查找成绩92：
	没有找到成绩92。

类适配器：对适配者进行继承或者实现接口
	适配器类实现了抽象目标类接口Target，并继承了适配者类，在适配器类的request()方法中调用所继承的适配者类的specificRequest()方法，实现了适配。