自分が見たデザインモデルに書く「戦略モデル」

一連のアルゴリズムを定義し、それらを一つ一つカプセル化し、互いに置き換えることができます.
シーン

システム内に多くのクラスがあり、それらの違いはそれらの動作のみにある場合、ポリシーモードを使用して、1つのオブジェクトが多くの動作の中で1つの動作

を動的に選択することができる.

システムは、いくつかのアルゴリズムの中で

を動的に選択する必要がある.

オブジェクトに多くの動作がある場合、適切なモードを使用しない場合、これらの動作は、

を実現するために複数の条件選択文を使用するしかない.
メリット

アルゴリズムは

を自由に切り替えることができる.

多重条件判定の使用を避ける.

拡張性良好

欠点

ポリシークラスは

増加します.

すべてのポリシークラスは、

を外部に暴露する必要があります.
使用

1.          
/**
 *        
 *
 * @author dkangel
 */
public abstract class AbstractStrategy {
    /**
     *     
     *
     * @param array       
     */
    public abstract void sort(int[] array);

    public void printArray(int[] array) {
        System.out.print("{ ");
        for (int i : array) {
            System.out.print(i + " ");
        }
        System.out.println("}");
    }
}

2.     、      
/**
 *   
 *
 * @author dkangel
 */
public class QuickStrategy extends AbstractStrategy {

    @Override
    public void sort(int[] array) {
        System.out.println("use quick sort");
        quickSort(array, 0, array.length - 1);
        super.printArray(array);
    }

    /**
     *     ：  flag（       ），             ，  ，             ，  ，
     *           ，          ，          。
     *      ：O(nlogn)
     *    ：   
     *
     * @param a          
     * @param left  leftIndex
     * @param right rightIndex
     */
    private void quickSort(int[] a, int left, int right) {
        if (left < right) {
            int flag = a[left];
            int i = left;
            int j = right;
            do {
                while (a[j] >= flag && j > i) {
                    j--;
                }
                if (a[j] < flag) {
                    int tmp = a[j];
                    a[j] = a[left];
                    a[left] = tmp;
                }
                while (a[i] <= flag && i < j) {
                    i++;
                }
                if (a[i] > flag) {
                    int tmp = a[i];
                    a[i] = a[j];
                    a[j] = tmp;
                }
            } while (i < j);
            quickSort(a, left, i);
            quickSort(a, i + 1, right);
        }
    }
}

/**
 *     
 *
 * @author dkangel
 */
public class BubbleStrategy extends AbstractStrategy {

    @Override
    public void sort(int[] array) {
        System.out.println("use bubble sort.");
        bubbleSort(array);
        super.printArray(array);
    }

    /**
     *     ：       ，          ，   “ ”   。
     *       ：O(n^2)
     *    ：  
     *
     * @param a      
     */
    private void bubbleSort(int[] a) {
        int len = a.length;
        for (int i = 0; i < len - 1; i++) {
            //                  ,    ，  j     len-1-i
            for (int j = 0; j < len - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                }
            }
        }
    }
}

3.       ，     
/**
 *     ，  Client Strategy
 *
 * @author dkangel
 */
public class Context {
    private AbstractStrategy abstractStrategy;

    public Context(AbstractStrategy abstractStrategy) {
        this.abstractStrategy = abstractStrategy;
    }

    public void executeStrategy(int[] arrays) {
        abstractStrategy.sort(arrays);
    }
}

4.   
/**
 *        
 *
 * @author dkangel
 */
public class Main {
    public static void main(String[] args) {
        int[] array = new int[]{3, 1, 9, 5};

        //       
        Context context = new Context(new QuickStrategy());
        context.executeStrategy(array);

        //         
        context = new Context(new BubbleStrategy());
        context.executeStrategy(array);
    }
}