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

Adapter.java
package Adapter;

public class Adapter implements DataOperation{

	private QuickSort quickSort;	//定义适配者QuickSort对象
	private BinarySearch binarySearch;	//定义适配者BinarySearch对象
	
	public Adapter(){
		quickSort=new QuickSort();
		binarySearch=new BinarySearch();
	}

	public void sort(int a[]) {
		quickSort.quickSort(a);
	}

	public int search(int a[],int start,int end,int key) {
		return binarySearch.binarySearch(a,start,end,key);
	}
}

BinarySearch.java
package Adapter;

public class BinarySearch {
	//二分查找算法
	public int binarySearch(int a[],int start,int end,int key) {
		int mid = (end - start) / 2 + start;
        if (a[mid] == key) {
            return mid;
        }

        if (start >= end) {
            return -1;

        } else if (key > a[mid]) {
            return binarySearch(a, mid + 1, end, key);

        } else if (key < a[mid]) {
            return binarySearch(a, start, mid - 1, key);

        }

        return -1;

    }
}

DataOperation.java
package Adapter;

public interface DataOperation {
	//定义排序方法和查找方法
	public void sort(int a[]);
	public int search(int a[],int start,int end,int key);
}

QuickSort .java
package Adapter;

import java.util.Arrays;

public class QuickSort {//实现快速排序
	public void quickSort(int a[]) {
		Arrays.sort(a);
	}
}

 Client.java
package Adapter;

import java.util.Scanner;

public class Client {

	public static void main(String[] args) {
		DataOperation dataOperation=new Adapter();
		int a[]= {4,6,7,3,2,8,0};
		System.out.println("未排序前的数组值为：");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
		dataOperation.sort(a);
		System.out.println("\n快速排序后数组的信息为：");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println("\n请输入你要查找的数");
		Scanner scanner=new Scanner(System.in);
		int key=scanner.nextInt();
		int start=0;
		int end=a.length-1;
		System.out.println("数字"+key+"在数组中的索引为："+dataOperation.search(a,start,end,key));
		scanner.close();
	}

}

优点：

1、将目标类和适配者类解耦

2、增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性

3、灵活性和扩展性都非常好，符合开闭原则

类适配器的缺点：

对于Java、C#等不支持多重继承的语言，一次最多只能适配一个适配者类，而且目标抽象类只能为接口，不能为类，其使用有一定的局限性，不能将一个适配者类和他的子类同时适配到目标接口。