策略模式

定义：是对算法的包装，把使用算法的的责任和算法本身分割开，委派给不同的对象管理，策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类型的子类型、就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”;

意图：针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以互相替换。策略模式使得算法可以在不影响到客户端的情况下发生变化;

public class StrategyDemo{
    public static void main(String []args){
        int[] array={1,30,64,88,12,56,28};
        ISort bubbleSort=new BubbleSort();
        Context con=new Context(bubbleSort);
        con.sort(array);
        con.printArray(array);
    }
}

class Context{
    private ISort iSort=null;
    public Context(ISort iSort)
    {
        this.iSort=iSort;
    }
    
    public void sort(int[] array){
        //交给具体的策略类对象来帮忙
        iSort.sort(array);
    }
    //打印数组中的内容
    public void printArray(int[] array){
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+" ");
        }
    }
}

interface ISort{
    public void sort(int[] array);
}

//封装了冒泡排序法
class BubbleSort implements ISort{
    public void sort(int[] array){
        System.out.println("冒泡排序法");
        for(int i=0;i<array.length-1;i++){
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
    }
}

//封装了选择排序法
class SelectSort implements ISort{
    public void sort(int[] array){
        System.out.println("选择排序法");
        int min=0;
        for(int i=0;i<array.length;i++){
            min=i;
            for(int j=i+1;j<array.length;j++){
                if(array[min]>array[j]){
                    min=j;
                }
            }
            if(i!=min){
                int temp=array[i];
                array[i]=array[min];
                array[min]=temp;
            }
        }
    }
}