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

---

一、前言

策略模式和工厂模式是两种不同的设计模式，它们有不同的目的和使用场景。

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

2.1 工厂模式

工厂模式提供了一种创建对象的机制，通过工厂方法来根据给定的参数返回一个对象。这种模式可以避免直接使用new操作符来创建对象，提高了代码的灵活性和可扩展性。
工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。
实现示例：
以普通工厂模式为例
建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

举例如下：（我们举一个发送邮件和短信的例子）
首先，创建二者的共同接口：

public interface Sender { 
 public void Send(); 
} 

其次，创建实现类：

public class MailSender implements Sender { 
 @Override 
 public void Send() { 
  System.out.println("this is mailsender!"); 
 } 
} 

public class SmsSender implements Sender { 
 
 @Override 
 public void Send() { 
  System.out.println("this is sms sender!"); 
 } 
} 

2.2 策略模式

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下：

策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。
实现示例：
首先统一接口：

public interface ICalculator { 
 public int calculate(String exp); 
} 

辅助类：

public abstract class AbstractCalculator { 
  
 public int[] split(String exp,String opt){ 
  String array[] = exp.split(opt); 
  int arrayInt[] = new int[2]; 
  arrayInt[0] = Integer.parseInt(array[0]); 
  arrayInt[1] = Integer.parseInt(array[1]); 
  return arrayInt; 
 } 
} 

三个实现类：

public class Plus extends AbstractCalculator implements ICalculator { 
 
 @Override 
 public int calculate(String exp) { 
  int arrayInt[] = split(exp,"\\+"); 
  return arrayInt[0]+arrayInt[1]; 
 } 
} 

public class Minus extends AbstractCalculator implements ICalculator { 
 
 @Override 
 public int calculate(String exp) { 
  int arrayInt[] = split(exp,"-"); 
  return arrayInt[0]-arrayInt[1]; 
 } 
}

public class Multiply extends AbstractCalculator implements ICalculator { 
 
 @Override 
 public int calculate(String exp) { 
  int arrayInt[] = split(exp,"\\*"); 
  return arrayInt[0]*arrayInt[1]; 
 } 
} 

简单的测试类：

public class StrategyTest { 
 
 public static void main(String[] args) { 
  String exp = "2+8"; 
  ICalculator cal = new Plus(); 
  int result = cal.calculate(exp); 
  System.out.println(result); 
 } 
} 

输出：10

2.3 区别

关注点不同：
策略模式关注的是算法的替换和变化，它强调的是行为的选择和执行。
工厂模式关注的是对象的创建，它强调的是实例化过程的控制和管理。
目的不同：
策略模式通过定义一组算法来实现行为的可替换性和灵活性。
工厂模式通过提供创建对象的接口来实现对象创建过程的解耦和灵活性。
实现方式不同：
策略模式包含策略接口和具体策略类，通过上下文类来使用不同的策略。
工厂模式包含工厂接口或抽象类和具体工厂类，通过工厂方法来创建对象。
应用场景不同：
策略模式适用于需要在运行时动态选择算法或行为的场景。
工厂模式适用于需要控制实例化过程，或者需要创建一系列相关对象的场景。

2.4 结合

结合使用策略模式和工厂模式，可以使系统更灵活。工厂模式用于创建具体的策略对象，而策略模式用于在运行时选择和执行这些策略。
示例：
下面的示例展示了如何结合使用策略模式和工厂模式。工厂模式负责创建策略对象，策略模式负责在运行时选择和执行策略。

策略接口

// IStrategy.cs
public interface IStrategy
{
    void Execute();
}

具体策略

// ConcreteStrategyA.cs
public class ConcreteStrategyA : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("执行策略 A");
    }
}

// ConcreteStrategyB.cs
public class ConcreteStrategyB : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("执行策略 B");
    }
}

策略工厂

// StrategyFactory.cs
public class StrategyFactory
{
    public IStrategy CreateStrategy(string strategyType)
    {
        return strategyType switch
        {
            "A" => new ConcreteStrategyA(),
            "B" => new ConcreteStrategyB(),
            _ => throw new ArgumentException("Invalid strategy type")
        };
    }
}

上下文类

// Context.cs
public class Context
{
    private IStrategy _strategy;

    public void SetStrategy(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void ExecuteStrategy()
    {
        _strategy.Execute();
    }
}

客户端代码

// Program.cs
using System;

class Program
{
    static void Main()
    {
        StrategyFactory factory = new StrategyFactory();
        Context context = new Context();

        // 选择策略类型，可以从配置文件、用户输入等获取
        string strategyType = "A";
        
        // 使用工厂创建策略
        IStrategy strategy = factory.CreateStrategy(strategyType);

        // 设置上下文策略并执行
        context.SetStrategy(strategy);
        context.ExecuteStrategy();

        // 切换到另一种策略
        strategyType = "B";
        strategy = factory.CreateStrategy(strategyType);
        context.SetStrategy(strategy);
        context.ExecuteStrategy();
    }
}

结合使用的好处
1、职责分离：
工厂模式负责创建具体的策略对象。
策略模式负责在运行时选择和执行策略。
2、扩展性强：
可以很容易地添加新的策略，而不需要修改上下文类和客户端代码，只需在工厂中增加对应的策略创建逻辑即可。
3、代码简洁：
客户端代码不需要了解策略的具体实现，只需通过工厂获取策略对象，并在上下文中使用即可。