简单记录一下，工厂模式（Factory Pattern）与策略模式（Strategy Pattern）的区别

工厂模式（Factory Pattern）与策略模式（Strategy Pattern）的区别

1. 工厂模式（Factory Pattern）

**定义：**工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

**目的：**主要是用来创建对象，隐藏了对象创建的细节，使得代码更加模块化，易于管理和扩展。

分类：

• 简单工厂模式（Simple Factory Pattern）
• 工厂方法模式（Factory Method Pattern）
• 抽象工厂模式（Abstract Factory Pattern）

**适用场景：**当需要创建的对象数量较少，且创建逻辑相似时，可以使用简单工厂模式；当需要创建的对象数量较多，且创建逻辑差异较大时，可以使用工厂方法模式或抽象工厂模式。

2. 策略模式（Strategy Pattern）

**定义：**策略模式是一种行为型设计模式，它定义了一系列的算法，并将每一个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。

**目的：**主要是用来定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。此模式让算法的变化独立于使用算法的客户。

**适用场景：**当存在多个算法，它们的行为相似但实现不同，或者当需要在运行时根据条件动态地选择算法时，可以使用策略模式。

Java代码例子
工厂模式（简单工厂模式）

java
// 产品接口  
interface Product {  
    void use();  
}  
  
// 具体产品A  
class ConcreteProductA implements Product {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductA");  
    }  
}  
  
// 具体产品B  
class ConcreteProductB implements Product {  
    @Override  
    public void use() {  
        System.out.println("Using ConcreteProductB");  
    }  
}  
  
// 工厂类  
class ProductFactory {  
    public static Product createProduct(String type) {  
        if ("A".equals(type)) {  
            return new ConcreteProductA();  
        } else if ("B".equals(type)) {  
            return new ConcreteProductB();  
        }  
        return null;  
    }  
}  
  
// 客户端  
public class FactoryPatternDemo {  
    public static void main(String[] args) {  
        Product productA = ProductFactory.createProduct("A");  
        productA.use();  
  
        Product productB = ProductFactory.createProduct("B");  
        productB.use();  
    }  
}

策略模式

java
// 策略接口  
interface Strategy {  
    void execute();  
}  
  
// 具体策略A  
class ConcreteStrategyA implements Strategy {  
    @Override  
    public void execute() {  
        System.out.println("Executing strategy A");  
    }  
}  
  
// 具体策略B  
class ConcreteStrategyB implements Strategy {  
    @Override  
    public void execute() {  
        System.out.println("Executing strategy B");  
    }  
}  
  
// 上下文类  
class Context {  
    private Strategy strategy;  
  
    public Context(Strategy strategy) {  
        this.strategy = strategy;  
    }  
  
    public void setStrategy(Strategy strategy) {  
        this.strategy = strategy;  
    }  
  
    public void executeStrategy() {  
        strategy.execute();  
    }  
}  
  
// 客户端  
public class StrategyPatternDemo {  
    public static void main(String[] args) {  
        Context context = new Context(new ConcreteStrategyA());  
        context.executeStrategy();  
  
        context.setStrategy(new ConcreteStrategyB());  
        context.executeStrategy();  
    }  
}

通过这两个例子，可以清晰地看到工厂模式和策略模式在目的、结构和适用场景上的区别。工厂模式主要用于对象的创建，而策略模式则用于定义算法族，并允许在运行时选择算法。