工厂模式和策略模式区

工厂模式（Factory Pattern）和策略模式（Strategy Pattern）是两种常见的设计模式，它们都用于解决不同场景下的代码组织问题。以下是它们的区别和应用场景的详细比较：

工厂模式（Factory Pattern）：
工厂模式是一种创建型设计模式，主要用于对象的创建。它通过将对象的创建逻辑封装到一个工厂类中，使得客户端不必关心对象的具体创建过程，从而提高代码的可扩展性和维护性。

核心思想：定义一个接口用于创建对象，并让子类决定实例化哪一个类。工厂模式将实例化操作推迟到子类中进行。

策略模式（Strategy Pattern）：

策略模式是一种行为型设计模式，它将算法、行为、或逻辑的不同实现封装成独立的策略类，并允许它们在运行时相互替换。策略模式通过将行为的具体实现分离出来，使得算法可以在不改变客户端代码的情况下动态改变。

核心思想：定义一系列算法或行为，并将它们封装到独立的策略类中，客户端可以根据需要在运行时选择合适的策略。

2.意图

工厂模式：解决对象的创建问题。通过将对象的创建封装在一个工厂中，避免客户端直接使用new关键字，使代码更具扩展性。

策略模式：解决行为的选择问题。通过将不同的行为封装为策略类，使得可以动态替换算法或行为。

3.应用场景

工厂模式的适用场景：

需要创建复杂对象时，且对象创建逻辑比较复杂。
客户端不需要知道具体的对象创建细节，只需要得到正确的对象实例。
代码中有多个具体类的创建逻辑，且未来可能会增加新的类。

策略模式的适用场景：

有多种算法、操作或行为可以互换，且可以在运行时动态选择。
需要避免使用大量if-else或switch语句来选择算法或行为。
想要将算法或行为与具体的业务逻辑分离，便于扩展和维护。

4.结构对比

工厂模式结构：
工厂类：负责创建对象的逻辑。
产品接口：定义产品对象的公共接口。
具体产品类：工厂类生产的具体产品。

策略模式结构：
上下文类：持有一个策略类的引用，并在运行时选择不同的策略执行相应的行为。
策略接口：定义不同策略类的公共接口。
具体策略类：封装具体的算法或行为。

5.代码示例
工厂模式示例

// 产品接口
interface Product {
    void create();
}

// 具体产品类
class ConcreteProductA implements Product {
    public void create() {
        System.out.println("Product A created");
    }
}

class ConcreteProductB implements Product {
    public void create() {
        System.out.println("Product B created");
    }
}

// 工厂类
class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct("A");
        product.create();  // 输出: Product A created
    }
}

策略模式示例

// 策略接口
interface Strategy {
    void execute();
}

// 具体策略类
class ConcreteStrategyA implements Strategy {
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    public void execute() {
        System.out.println("Executing strategy B");
    }
}

// 上下文类
class Context {
    private Strategy strategy;

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Context context = new Context();

        context.setStrategy(new ConcreteStrategyA());
        context.executeStrategy();  // 输出: Executing strategy A

        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy();  // 输出: Executing strategy B
    }
}

6.优缺点

工厂模式的优点：
解耦了对象的创建过程，便于扩展新的产品类。
提高了代码的灵活性和可维护性。

工厂模式的缺点：
可能增加代码的复杂性，尤其是涉及多个工厂类时。
难以处理非常复杂的对象创建逻辑。

策略模式的优点：
避免了大量的if-else或switch语句，使得算法选择更加灵活。
可以动态改变策略，扩展新的策略类无需修改现有代码。

策略模式的缺点：
可能导致策略类数量过多，增加代码管理的复杂性。
上下文类必须知道策略的接口，增加了客户端的复杂度。