工厂模式和策略模式的区别

工厂模式和策略模式是两种不同的设计模式

一、目的和用途

1. 工厂模式（用于创建对象，将对象的创建和使用分离）：

   • 目的是创建对象，将对象的创建和使用分离。它提供了一种创建对象的方式，使得客户端代码不需要直接实例化具体的类，而是通过工厂类来创建对象。

   • 常用于创建复杂对象或根据不同的条件创建不同类型的对象，提高代码的可维护性和可扩展性。

     

2. 策略模式（主要用于封装算法或行为，使得不同算法或行为可以相互替换）：

   • 目的是封装一系列的算法或行为，使得这些算法或行为可以相互替换。它将算法的选择和实现分离，使得客户端代码可以在运行时根据需要选择不同的算法。

   • 常用于实现多种不同的算法或行为，并且这些算法或行为可以根据不同的情况进行切换。

     

二、结构和实现方式

1. 工厂模式：
   • 通常包含一个工厂类和多个具体产品类。工厂类负责创建具体产品类的实例，客户端代码只与工厂类交互，而不直接与具体产品类交互。
   • 工厂类可以是简单工厂、工厂方法或抽象工厂，具体实现方式根据实际需求而定。
2. 策略模式：
   • 通常包含一个策略接口和多个具体策略实现类，以及一个环境类。策略接口定义了算法的公共接口，具体策略实现类实现了策略接口，环境类持有一个策略对象，并在运行时根据需要选择不同的策略。
   • 客户端代码通过环境类来使用策略，而环境类可以在运行时根据需要动态地切换策略。

三、代码示例

1. 工厂模式示例：
   • 假设我们有一个图形绘制的应用程序，需要根据用户的选择绘制不同类型的图形，如圆形、矩形和三角形。我们可以使用工厂模式来创建这些图形对象。
   • 定义一个图形接口：

     public interface Shape {
         void draw();
     }

• 实现具体的图形类：

     public class Circle implements Shape {
         @Override
         public void draw() {
             System.out.println("Drawing a circle.");
         }
     }

     public class Rectangle implements Shape {
         @Override
         public void draw() {
             System.out.println("Drawing a rectangle.");
         }
     }

     public class Triangle implements Shape {
         @Override
         public void draw() {
             System.out.println("Drawing a triangle.");
         }
     }

• 创建一个图形工厂类：

     public class ShapeFactory {
         public static Shape createShape(String shapeType) {
             if (shapeType.equalsIgnoreCase("circle")) {
                 return new Circle();
             } else if (shapeType.equalsIgnoreCase("rectangle")) {
                 return new Rectangle();
             } else if (shapeType.equalsIgnoreCase("triangle")) {
                 return new Triangle();
             } else {
                 return null;
             }
         }
     }

• 客户端代码可以使用工厂类来创建图形对象：

     public class Client {
         public static void main(String[] args) {
             Shape shape1 = ShapeFactory.createShape("circle");
             shape1.draw();

             Shape shape2 = ShapeFactory.createShape("rectangle");
             shape2.draw();

             Shape shape3 = ShapeFactory.createShape("triangle");
             shape3.draw();
         }
     }

1. 策略模式示例：
   • 假设我们有一个排序算法的应用程序，需要根据用户的选择使用不同的排序算法，如冒泡排序、快速排序和插入排序。我们可以使用策略模式来实现这些排序算法。
   • 定义一个排序策略接口：

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

• 实现具体的排序策略类：

     public class BubbleSort 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;
                     }
                 }
             }
         }
     }

     public class QuickSort implements SortingStrategy {
         @Override
         public void sort(int[] array) {
             quickSort(array, 0, array.length - 1);
         }

         private void quickSort(int[] array, int low, int high) {
             if (low < high) {
                 int pivotIndex = partition(array, low, high);
                 quickSort(array, low, pivotIndex - 1);
                 quickSort(array, pivotIndex + 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;
         }
     }

     public class InsertionSort implements SortingStrategy {
         @Override
         public void sort(int[] array) {
             int n = array.length;
             for (int i = 1; i < n; i++) {
                 int key = array[i];
                 int j = i - 1;
                 while (j >= 0 && array[j] > key) {
                     array[j + 1] = array[j];
                     j--;
                 }
                 array[j + 1] = key;
             }
         }
     }

• 创建一个环境类，用于持有排序策略对象并调用排序算法：

     public class Sorter {
         private SortingStrategy sortingStrategy;

         public Sorter(SortingStrategy sortingStrategy) {
             this.sortingStrategy = sortingStrategy;
         }

         public void setSortingStrategy(SortingStrategy sortingStrategy) {
             this.sortingStrategy = sortingStrategy;
         }

         public void sortArray(int[] array) {
             sortingStrategy.sort(array);
         }
     }

• 客户端代码可以使用环境类来选择不同的排序策略：

     public class Client {
         public static void main(String[] args) {
             int[] array1 = {5, 3, 8, 4, 2};
             Sorter sorter1 = new Sorter(new BubbleSort());
             sorter1.sortArray(array1);
             print("Bubble Sort: ");
             for (int num : array1) {
                 System.out.print(num + " ");
             }
             System.out.println();

             int[] array2 = {9, 7, 6, 1, 3};
             Sorter sorter2 = new Sorter(new QuickSort());
             sorter2.sortArray(array2);
             print("Quick Sort: ");
             for (int num : array2) {
                 System.out.print(num + " ");
             }
             System.out.println();

             int[] array3 = {4, 2, 7, 1, 8};
             Sorter sorter3 = new Sorter(new InsertionSort());
             sorter3.sortArray(array3);
             print("Insertion Sort: ");
             for (int num : array3) {
                 System.out.print(num + " ");
             }
             System.out.println();
         }
     }