设计模式-适配器模式

现有一个接口DataOperation定义了排序方法sort(int[]) 和查找方法search(int[], int),已知类QuickSortquickSort(int[])方法实现了快速排序算法,类BinarySearch binarySearch(int[], int)方法实现了二分查找算法。试使用适配器模式设计一个系统,在不修改源代码的情况下将类QuickSort和类BinarySearch的方法适配到DataOperation接口中。绘制类图并编程实现。(要求实现快速排序和二分查找,使用对象适配器实现)

类图:

 

实现代码:

目标抽象类DataOperation

public interface DataOperation {

    public void sort(int[] a,int low,int high);

    public int search(int [] srcArray, int start, int end, int key);

}

适配者类QuickSort

public class QuickSort {

    public  void quickSout(int[] a,int low,int high){

            int start = low;

            int end = high;

            int key = a[low];

            while(end>start){

                //从后往前比较

                while(end>start&&a[end]>=key)  //如果没有比关键值小的,比较下一个,直到有比关键值小的交换位置,然后又从前往后比较

                    end--;

                if(a[end]<=key){

                    int temp = a[end];

                    a[end] = a[start];

                    a[start] = temp;

                }

                //从前往后比较

                while(end>start&&a[start]<=key)//如果没有比关键值大的,比较下一个,直到有比关键值大的交换位置

                    start++;

                if(a[start]>=key){

                    int temp = a[start];

                    a[start] = a[end];

                    a[end] = temp;

                }

                //此时第一次循环比较结束,关键值的位置已经确定了。左边的值都比关键值小,右边的值都比关键值大,但是两边的顺序还有可能是不一样的,进行下面的递归调用

            }

            //递归

            if(start>low) quickSout(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1

            if(end<high) quickSout(a,end+1,high);//右边序列。从关键值索引+1到最后一个

        }

    }

适配者类BinarySearch

public class BinarySearch {

    public int binarySearch(int srcArray[], int start, int end, int key){

        int mid = (end - start) / 2 + start;

        if (srcArray[mid] == key) {

            return mid;

        }

        if (start >= end) {

            return -1;

        } else if (key > srcArray[mid]) {

            return binarySearch(srcArray, mid + 1, end, key);

        } else if (key < srcArray[mid]) {

            return binarySearch(srcArray, start, mid - 1, key);

        }

        return -1;

    }

}

适配器类DataOpAdapter

public class DataOpAdapter implements DataOperation {

    private QuickSort qSort;

    private BinarySearch binarySearch;

public DataOpAdapter(QuickSort qSort,BinarySearch binarySearch) {

    this.qSort=qSort;

    this.binarySearch=binarySearch;

}

    @Override

    public int search(int [] srcArray, int start, int end, int key){

        return  binarySearch.binarySearch(srcArray,start,end,key);

    }

    @Override

    public void sort(int[] a,int low,int high) {

        qSort.quickSout(a,low,high);

    }

}

客户端类Main

public class Main {

    public static void main(String[] args) {

        DataOperation dataOperation =new DataOpAdapter(new QuickSort(), new BinarySearch());

        int[] a = {12,20,5,16,15,1,30,45,23,9};

        System.out.println("排序前:");

        for(int i = 0; i<a.length; i++){

            System.out.print(a[i]+" ");

        }

        int start = 0;

        int end = a.length-1;

        dataOperation.sort(a,start,end);

        System.out.println("\n"+"实现快速排序:");

        for(int i = 0; i<a.length; i++){

            System.out.print(a[i]+" ");

        }

        System.out.println("\n"+"实现了二分查找算法,查找“20");

        System.out.println(dataOperation.search(a,0,a.length -1,20));

    }

}



猜你喜欢

转载自blog.csdn.net/qq_35522904/article/details/80055931