简单工厂模式（Simple Factory Pattern）和策略模式（Strategy Pattern）

简单工厂模式（Simple Factory Pattern）：

1. 定义：

   • 简单工厂模式属于创建型设计模式，它提供了一个工厂类，根据传入的参数或条件动态创建并返回合适的具体对象实例。
   • 这种模式通过将对象的创建逻辑封装在一个工厂类中，使得客户端代码不需要直接创建对象，而是通过工厂类来获取所需的对象。

策略模式（Strategy Pattern）：

1. 定义：

   • 策略模式属于行为型设计模式，它定义了一系列的算法（策略），将每个算法封装起来，并使它们可以互相替换。客户端通过策略对象来选择不同的算法实现。
   • 这种模式通过将算法的实现从使用算法的客户端代码中解耦，提供了更大的灵活性和可维护性。

区别：

        假设我们有一个电商平台，用户在结账时可以选择不同的支付方式进行支付，例如支付宝、微信支付和信用卡支付。

        简单工厂模式实现：

定义支付接口和具体支付类：

// 支付接口
public interface Payment {
    void pay(double amount);
}

// 微信支付实现类
public class WechatPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount + "元。");
    }
}

// 支付宝支付实现类
public class AlipayPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元。");
    }
}

// 简单工厂类
public class PaymentFactory {
    public static Payment createPayment(String type) {
        if ("wechat".equalsIgnoreCase(type)) {
            return new WechatPayment();
        } else if ("alipay".equalsIgnoreCase(type)) {
            return new AlipayPayment();
        } else {
            throw new IllegalArgumentException("Unsupported payment type.");
        }
    }
}

客户端使用简单工厂模式选择支付方式：

public class Client {
    public static void main(String[] args) {
        // 客户端根据需求选择支付方式
        String paymentType = "wechat"; // 可以根据实际情况来动态选择支付方式

        // 使用简单工厂创建支付对象
        Payment payment = PaymentFactory.createPayment(paymentType);
        payment.pay(100.0); // 进行支付
    }
}

上述代码中，PaymentFactory 是简单工厂模式的实现，根据客户端传入的参数（支付类型），动态创建并返回对应的支付对象（WechatPayment 或 AlipayPayment）。客户端只需通过工厂类来获取支付对象，而不需要直接实例化具体的支付类。

        策略模式实现：

定义支付策略接口和具体策略类：

// 支付策略接口
public interface PaymentStrategy {
    void pay(double amount);
}

// 微信支付策略
public class WechatPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount + "元。");
    }
}

// 支付宝支付策略
public class AlipayPaymentStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元。");
    }
}

// 上下文类
public class PaymentContext {
    private PaymentStrategy strategy;

    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void pay(double amount) {
        strategy.pay(amount);
    }
}

客户端使用策略模式选择支付方式：

public class Client {
    public static void main(String[] args) {
        // 客户端根据需求选择支付方式
        String paymentType = "alipay"; // 可以根据实际情况来动态选择支付方式

        // 根据选择的支付方式创建对应的支付策略对象
        PaymentStrategy strategy;
        if ("wechat".equalsIgnoreCase(paymentType)) {
            strategy = new WechatPaymentStrategy();
        } else if ("alipay".equalsIgnoreCase(paymentType)) {
            strategy = new AlipayPaymentStrategy();
        } else {
            throw new IllegalArgumentException("Unsupported payment type.");
        }

        // 使用策略对象进行支付
        PaymentContext context = new PaymentContext(strategy);
        context.pay(100.0); // 进行支付
    }
}

上述代码中，PaymentStrategy 是策略接口，定义了支付的方法。具体的支付方式（WechatPaymentStrategy 和 AlipayPaymentStrategy）分别实现了这个接口。客户端根据需求选择不同的支付方式，创建对应的策略对象，并将其传递给 PaymentContext 上下文对象。上下文对象根据传入的策略对象调用相应的支付方法。

总结

• 简单工厂模式用于创建对象，根据不同的条件返回不同的对象实例。
• 策略模式用于定义一系列算法（策略），将每个算法封装起来，并使其可以互相替换，客户端可以动态选择和使用这些算法。

简单工厂模式侧重于对象的创建过程的封装，而策略模式侧重于算法的封装和选择。在实际应用中，根据具体的需求和场景选择合适的设计模式能够更好地提升代码的灵活性和可维护性。