Java【策略模式】

 策略模式定义：是对算法的包装，把使用算法的责任和本身分割开，委派给不同的对象管理。

                          策略模式通常把一系列的算法包装到一系列的类中，作为一个抽象策略类型的子类型

              目的：针对一组算法，将每一组算法封装到具有共同接口的一个类中，从而可以是它们可以互相替换

public class Main(){

    public static void mian(String []args){

        int []array = {23,6,79,44,66,43};
        ISort bubbleSort = new BubbleSort();
        Context context = new Context(bubbleSort );
        context.sort(array);
        context.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{
        for(int i = 0; i <array.length ; i++){
             System.out.print(array[i] + " ");
        }
    }
}

interfance ISort{

    public void sort(int [] array);
}

//封装冒泡排序法
class BubbleSort implements ISort{

    public void sort(int [] array){
        for（int i=0;i<array.length-1;i++）{
            for(int j=0;j<array.length-1-i;j++){
                if(array[i]>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){
        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;
            }
        }
    }
}