工厂模式和策略模式的区别，以及java代码示例

工厂模式和策略模式是两种不同的设计模式，主要用来解决不同的问题。

工厂模式是一种创建型模式，用来创建对象的实例。它通过一个工厂类来创建具体的对象，而不是在客户端直接实例化对象。工厂模式主要用于解决对象的创建过程复杂或不适合直接在客户端创建的问题。工厂模式将创建对象的过程封装在一个工厂类中，客户端只需要通过工厂类来创建所需的对象。

策略模式是一种行为型模式，用来封装一系列可互相替换的算法。它定义了一系列算法类，将每个算法封装成一个独立的类，并使它们可以互相替换。策略模式主要用于解决在运行时根据不同的需求选择不同的算法的问题。客户端通过使用不同的策略对象来选择不同的算法，从而达到动态改变行为的目的。

下面是一个简单的Java代码示例，演示了工厂模式和策略模式的使用：

// 工厂模式示例
// 定义一个工厂类来创建对象
class ShapeFactory {
    public Shape createShape(String type) {
        if (type.equals("circle")) {
            return new Circle();
        } else if (type.equals("rectangle")) {
            return new Rectangle();
        } else if (type.equals("triangle")) {
            return new Triangle();
        }
        return null;
    }
}

// 定义一个抽象的形状类
abstract class Shape {
    abstract void draw();
}

// 定义具体的形状类
class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

class Triangle extends Shape {
    void draw() {
        System.out.println("Drawing a triangle.");
    }
}

// 使用工厂类创建对象
public class FactoryPatternDemo {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();

        Shape circle = factory.createShape("circle");
        circle.draw(); // 输出：Drawing a circle.

        Shape rectangle = factory.createShape("rectangle");
        rectangle.draw(); // 输出：Drawing a rectangle.

        Shape triangle = factory.createShape("triangle");
        triangle.draw(); // 输出：Drawing a triangle.
    }
}

// 策略模式示例
// 定义一个策略接口
interface SortStrategy {
    void sort(int[] array);
}

// 定义具体的策略类
class BubbleSortStrategy implements SortStrategy {
    public void sort(int[] array) {
        System.out.println("Using bubble sort strategy.");
        // 实现具体的排序算法
        // ...
    }
}

class QuickSortStrategy implements SortStrategy {
    public void sort(int[] array) {
        System.out.println("Using quick sort strategy.");
        // 实现具体的排序算法
        // ...
    }
}

class MergeSortStrategy implements SortStrategy {
    public void sort(int[] array) {
        System.out.println("Using merge sort strategy.");
        // 实现具体的排序算法
        // ...
    }
}

// 使用策略对象进行排序
public class StrategyPatternDemo {
    public static void main(String[] args) {
        SortStrategy strategy;

        strategy = new BubbleSortStrategy();
        strategy.sort(new int[]{5, 3, 8, 1, 2}); // 输出：Using bubble sort strategy.

        strategy = new QuickSortStrategy();
        strategy.sort(new int[]{5, 3, 8, 1, 2}); // 输出：Using quick sort strategy.

        strategy = new MergeSortStrategy();
        strategy.sort(new int[]{5, 3, 8, 1, 2}); // 输出：Using merge sort strategy.
    }
}

以上代码示例分别演示了工厂模式和策略模式的使用。工厂模式通过一个工厂类来创建不同的形状对象，策略模式通过不同的策略对象来选择不同的排序算法。