轻松理解设计模式——模板方法模式

模板方法模式：定义一个操作中算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤。

模板方法模式，是框架设计中用到频率最高的几种设计模式之一，像spring中有很多地方用到该设计模式。
本文是一个小demo,相信你看完会感概一句：原来传说中的模板方法模式这么简单！

代码展示：

package com.kevinlsui.test;

/**
 * 抽象类
 */
public abstract class Sort {
    
    //定义一个骨架，步骤123，但是算法核心实现，由各子类来完成
    public void arraySort(int[] arr){
        //1.验证参数
        int length = arr.length;
        if(length < 2){
            System.out.println("数组长度小于2，请检查待排序数组！！！");
        }

        //2.排序实现
        sortImpl(arr);

        //3.结果展示
        for(int i = 0 ; i < length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        System.out.println("----------排序完成----------");
    }
    
    //抽象方法，等子类实现
    protected abstract void sortImpl(int[] arr);


}

package com.kevinlsui.test;

/**
 * 实现类1
 */
public class QuickSort extends Sort {
    //子类实现，模板方法
    @Override
    protected void sortImpl(int[] arr) {
        System.out.println("我用快速排序算法实现的。。。");
        //排序
        sortArr(arr,0,arr.length-1);
    }

    //快速排序，复习下算法
    private void sortArr(int[] arr , int min ,int max){
        if(min < max){//出口条件
            int len1 = min;
            int len2 = max;

            int temp = arr[min];//基准点，这里可以使用“三数取中”优化
            while (min < max){
                while (min < max && arr[max] >= temp){
                    max--;
                }
                arr[min] = arr[max];

                while (min < max && arr[min] <= temp){
                    min++;
                }
                arr[max] = arr[min];
            }
            arr[min] = temp;

            sortArr(arr,len1,min-1);
            sortArr(arr,min+1,len2);

        }

    }
}

package com.kevinlsui.test;

/**
 * 实现类2
 */
public class MergeSort extends Sort {

     //子类实现，模板方法
    @Override
    protected void sortImpl(int[] arr) {
        System.out.println("我用归并排序算法实现的。。。");
        //归并
        sortArr(arr,0,arr.length-1);
    }

    //归并排序算法实现
    private void sortArr(int[] arr,int min,int max){
        if (min < max){
            int mid = (min+max)/2;
            sortArr(arr,min,mid);
            sortArr(arr,mid+1,max);
            merge(arr,min,mid,max);

        }

    }
    //合并实现
    private void merge(int[] arr, int min, int mid, int max) {
        int[] temp = new int[max-min+1];//按需设置数组长度
        int index = 0;
        int left = min;//左指针
        int right = mid+1;

        //合并
        while (left <= mid && right <= max){
            if(arr[left] > arr[right]){
                temp[index++] = arr[right++];
            }else{
                temp[index++] = arr[left++];
            }
        }
        //某一半数字用完了
        while (left <= mid){
            temp[index++] = arr[left++];
        }
        while (right <= max){
            temp[index++]=arr[right++];
        }

        //临时数组数据放回原数组
        for(int i = 0 ;i < temp.length;i++){
            arr[min++] = temp[i];
        }
    }


}

package com.kevinlsui.test;

/**
 * 测试类
 */
public class SortTest {
    public static void main(String[] args) {
        int[] arr = {32,12,89,24,10,66,2,32,45,10};

        Sort sort1 = new QuickSort();
        sort1.arraySort(arr);

        Sort sort2 = new MergeSort();
        sort2.arraySort(arr);
    }
}

//结果：

// 我用快速排序算法实现的。。。
// 2 10 10 12 24 32 32 45 66 89 
// ----------排序完成----------
// 我用归并排序算法实现的。。。
// 2 10 10 12 24 32 32 45 66 89 
// ----------排序完成----------