乐趣区

关于java:Java策略模式简单示例代码

jiezi

以下是应用 Java 实现冒泡排序、抉择排序和疾速排序的示例代码，应用策略模式实现：

  1. 首先，定义一个策略接口 SortingStrategy，蕴含一个排序办法 sort：

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

  2. 而后，实现三个具体的策略类，别离代表不同的排序算法：

    public class BubbleSortStrategy implements SortingStrategy {
 @Override
 public void sort(int[] array) {
     int n = array.length;
     for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (array[j] > array[j + 1]) {int temp = array[j];
                 array[j] = array[j + 1];
                 array[j + 1] = temp;
             }
         }
     }
     System.out.println("Sorting using bubble sort:" + Arrays.toString(array));
 }
}
    public class SelectionSortStrategy implements SortingStrategy {
 @Override
 public void sort(int[] array) {
     int n = array.length;
     for (int i = 0; i < n - 1; i++) {
         int minIndex = i;
         for (int j = i + 1; j < n; j++) {if (array[j] < array[minIndex]) {minIndex = j;}
         }
         int temp = array[minIndex];
         array[minIndex] = array[i];
         array[i] = temp;
     }
     System.out.println("Sorting using selection sort:" + Arrays.toString(array));
 }
}
    public class QuickSortStrategy implements SortingStrategy {
 @Override
 public void sort(int[] array) {quickSort(array, 0, array.length - 1);
     System.out.println("Sorting using quick sort:" + Arrays.toString(array));
 }

 private void quickSort(int[] array, int low, int high) {if (low < high) {int pivot = partition(array, low, high);
         quickSort(array, low, pivot - 1);
         quickSort(array, pivot + 1, high);
     }
 }

 private int partition(int[] array, int low, int high) {int pivot = array[high];
     int i = low - 1;
     for (int j = low; j < high; j++) {if (array[j] < pivot) {
             i++;
             int temp = array[i];
             array[i] = array[j];
             array[j] = temp;
         }
     }
     int temp = array[i + 1];
     array[i + 1] = array[high];
     array[high] = temp;
     return i + 1;
 }
}

  3. 接下来，能够应用策略模式进行排序操作：

    public class Main {public static void main(String[] args) {int[] array = {5, 2, 8, 3, 1};

     // 抉择排序策略并创立相应的策略对象
     SortingStrategy sortingStrategy = new BubbleSortStrategy();
     // 或者 SortingStrategy sortingStrategy = new SelectionSortStrategy();
     // 或者 SortingStrategy sortingStrategy = new QuickSortStrategy();

     // 执行排序操作
     sortingStrategy.sort(array);
 }
}

在上述示例中，咱们定义了三种排序策略：冒泡排序、抉择排序和疾速排序。依据需要，咱们抉择其中一种策略，并将其传递给策略对象 sortingStrategy。而后，调用 sort 办法执行排序操作。

输入后果将依据所选的排序策略不同而有所不同。

策略模式容许在运行时动静抉择不同的策略，因而能够依据理论需要灵便地切换排序算法，而不须要批改应用排序策略的代码。

退出移动版