【设计模式】工厂模式与策略模式的区别

类Product定义了Factory Method所创建的对象的接口。
类ConcreteProduct用于实现Product接口。【Concrete：具体、确定的】
类Creator声明了工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。
类ConcreteCreator重定义了工厂方法，以返回一个ConcreteProduct实例。

2、策略模式

一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

主要角色：

环境（Context）：维护一个对策略对象的引用，负责将客户端请求委派给具体的策略对象执行。环境类可以通过依赖注入、简单工厂等方式来获取具体策略对象。
抽象策略（Abstract Strategy）：定义了策略对象的公共接口或抽象类，规定了具体策略类必须实现的方法。
具体策略（Concrete Strategy）：实现了抽象策略定义的接口或抽象类，包含了具体的算法实现。

3、区别

工厂模式（Factory Pattern）和策略模式（Strategy Pattern）是两种常见的设计模式，它们的主要目标是通过分离和封装变化点来提高代码的灵活性和可维护性。虽然它们都涉及到对象的创建和行为的封装，但它们在关注点和使用场景上有明显的区别。

3.1、工厂模式

1. 目的：

工厂模式的目的是封装对象的创建逻辑，通过提供一个接口或方法来创建对象，而不是直接在代码中显式使用 new 操作符。这使得代码在需要创建不同类型对象时更加灵活，便于扩展和维护。

2. 使用场景：

当你的系统需要根据条件（比如配置、参数、环境）创建不同类型的对象，并且这些对象可能在未来会有所扩展时，工厂模式是一个不错的选择。你可以通过工厂类来创建对象，而不需要在代码中显式地知道对象的具体类型。

3. 实现方式：

工厂模式可以有多种变体，包括简单工厂（Simple Factory）、工厂方法（Factory Method）和抽象工厂（Abstract Factory）。核心思想是通过工厂方法来创建对象，隐藏具体的创建逻辑。

4. 示例：

// 产品接口
interface Car {
    void drive();
}

// 具体产品类
class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a sedan.");
    }
}

class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV.");
    }
}

// 工厂类
class CarFactory {
    public static Car createCar(String carType) {
        if ("sedan".equalsIgnoreCase(carType)) {
            return new Sedan();
        } else if ("suv".equalsIgnoreCase(carType)) {
            return new SUV();
        }
        throw new IllegalArgumentException("Unknown car type: " + carType);
    }
}

// 测试工厂模式
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Car car = CarFactory.createCar("sedan");
        car.drive();  // 输出: Driving a sedan.

        Car car2 = CarFactory.createCar("suv");
        car2.drive();  // 输出: Driving an SUV.
    }
}

3.2、策略模式

1. 目的：

策略模式的目的是封装不同的算法或行为，并让它们可以相互替换，且算法的变化不会影响使用它的客户端代码。它主要用于解决具有多个行为或算法的场景，通过策略模式将这些行为抽象为独立的策略对象，客户端可以根据需要选择不同的策略。

2. 使用场景：

当你有多种不同的算法、业务逻辑、或者行为可以应用到某个对象或场景中，并且这些行为之间是可替换的，策略模式就非常有用。它能够让客户端灵活地选择算法，而不会影响其他的代码逻辑。

3. 实现方式：

策略模式的实现通常是定义一个接口（或抽象类）表示策略，然后通过不同的策略实现类来实现不同的算法。客户端在运行时选择使用哪一个策略。

4. 示例：

// 定义策略接口
interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略类
class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using credit card.");
    }
}

class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using PayPal.");
    }
}

// 上下文类
class ShoppingCart {
    private PaymentStrategy strategy;

    // 通过构造方法注入策略
    public ShoppingCart(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void checkout(int amount) {
        strategy.pay(amount);
    }
}

// 测试策略模式
public class StrategyPatternDemo {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart(new CreditCardPayment());
        cart.checkout(100);  // 输出: Paying 100 using credit card.

        cart = new ShoppingCart(new PayPalPayment());
        cart.checkout(200);  // 输出: Paying 200 using PayPal.
    }
}

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

区别点	工厂模式	策略模式
核心关注点	封装对象的创建逻辑	封装对象的行为或算法
目的	将对象的创建逻辑与使用逻辑分离，避免直接使用构造函数创建对象	将不同的算法或行为封装为独立的策略，允许客户端选择不同策略
使用场景	需要根据条件创建不同类型的对象时	需要根据情况选择不同的算法或行为，并且这些算法可互换时
实现方式	通过一个工厂类或方法创建具体对象	定义策略接口，不同的策略实现具体的算法或行为
代码结构	关注的是创建过程，不涉及对象的具体行为	关注的是行为的多样性，通过策略对象来决定行为
代码扩展性	新增对象类型时，扩展工厂方法	新增算法时，只需要增加新的策略类

3.3、总结

工厂模式 ：用于处理对象创建问题，使得创建对象的代码与使用对象的代码解耦。它关注的是"创建什么对象"。
策略模式 ：用于处理算法或行为的变化和扩展，客户端可以在不同的算法或行为之间灵活切换。它关注的是"怎么做某件事"。

4、案例

1）某银行系统采用Factory Method方法描述其不同账户之间的关系，设计出的类图如下所示。其中与Factory Method中的"Creator"角色相对应的类是（）；与"Product"角色相对应的类是（）。

"Creator"角色相对应的类是Bank；与"Product"角色相对应的类是Account。

更多的考点案例，可以使用软考真题 APP 加以训练。

可以在"智能练题" 模块输入 "设计模式" 自定义练题

5、23种设计模式

带*****的表示类，其他是对象