模板和策略设计模式联合使用的demo

在联合使用模板设计模式和策略设计模式时，我们可以定义一个模板类，该类包含了一些固定步骤的算法，并在其中使用策略接口来允许子类提供不同的实现。这样，我们可以在不改变算法结构的情况下改变算法中的某些步骤。

以下是一个简单的例子，展示了如何联合使用模板设计模式和策略设计模式：

首先，我们定义一个策略接口：

java 复制代码

public interface PaymentStrategy {
    void pay(double amount);
}

然后，我们实现两种支付策略：

java 复制代码

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with credit card for amount: " + amount);
    }
}

public class BankTransferPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paying with bank transfer for amount: " + amount);
    }
}

接下来，我们定义一个模板类，它接受一个支付策略对象，并在其算法中使用这个策略对象：

java 复制代码

public abstract class PaymentProcessor {
    private PaymentStrategy strategy;

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

    public void processPayment(double amount) {
        // 固定步骤1：准备支付环境
        prepareEnvironment();

        // 策略步骤：执行支付
        strategy.pay(amount);

        // 固定步骤2：支付后处理
        postProcessPayment();
    }

    // 模板方法，固定步骤的实现
    protected void prepareEnvironment() {
        System.out.println("Preparing payment environment...");
    }

    // 模板方法，固定步骤的实现
    protected void postProcessPayment() {
        System.out.println("Payment processed successfully!");
    }
}

最后，我们创建具体的支付处理器类，它们继承自PaymentProcessor并传入具体的支付策略：

java 复制代码

public class CreditCardPaymentProcessor extends PaymentProcessor {
    public CreditCardPaymentProcessor() {
        super(new CreditCardPayment());
    }

    // 可以重写固定步骤，如果需要的话
    @Override
    protected void prepareEnvironment() {
        System.out.println("Verifying credit card details...");
    }
}

public class BankTransferPaymentProcessor extends PaymentProcessor {
    public BankTransferPaymentProcessor() {
        super(new BankTransferPayment());
    }

    // 可以重写固定步骤，如果需要的话
    @Override
    protected void prepareEnvironment() {
        System.out.println("Checking bank account balance...");
    }
}

现在，我们可以使用这些支付处理器来执行支付：

java 复制代码

public class Main {
    public static void main(String[] args) {
        PaymentProcessor creditCardProcessor = new CreditCardPaymentProcessor();
        creditCardProcessor.processPayment(100.0);

        PaymentProcessor bankTransferProcessor = new BankTransferPaymentProcessor();
        bankTransferProcessor.processPayment(200.0);
    }
}

输出结果：

csharp 复制代码

Verifying credit card details...
Paying with credit card for amount: 100.0
Payment processed successfully!
Checking bank account balance...
Paying with bank transfer for amount: 200.0
Payment processed successfully!

在这个例子中，PaymentProcessor是模板类，它定义了支付处理的算法骨架，而PaymentStrategy是策略接口，允许我们提供不同的支付实现。CreditCardPaymentProcessor和BankTransferPaymentProcessor是具体的支付处理器，它们通过组合PaymentProcessor和具体的策略对象来提供不同的支付功能。