设计模式实践应用

一、策略模式

问题：什么是设计模式中的策略模式？请举一个简单的例子

策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，将每一个算法封装起来，并且使它们可以互换。策略模式让算法独立于使用它的客户端而变化。

在策略模式中，通常会有三种角色：

1. 策略接口（Strategy Interface）：定义了所有支持的算法的公共接口。通常是通过一个接口或者抽象类来实现的。

2. 具体策略类（Concrete Strategies）：实现了策略接口的具体算法。

3. 上下文（Context）：持有一个策略接口的引用，用于执行某个具体的策略。

下面是一个简单的例子，假设我们有一个电商平台，针对不同的支付方式（策略），我们希望实现不同的计算支付金额的算法：

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

// 2. 具体策略类：支付宝支付
class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " dollars using Alipay.");
    }
}

// 具体策略类：微信支付
class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " dollars using WeChat Pay.");
    }
}

// 3. 上下文
class PaymentContext {
    private PaymentStrategy paymentStrategy;

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

    public void executePayment(int amount) {
        paymentStrategy.pay(amount);
    }
}

// 使用示例
public class StrategyPatternExample {
    public static void main(String[] args) {
        // 使用支付宝支付
        PaymentContext context = new PaymentContext(new AlipayStrategy());
        context.executePayment(100);

        // 使用微信支付
        context = new PaymentContext(new WechatPayStrategy());
        context.executePayment(200);
    }
}

在上面的例子中：

• PaymentStrategy 是策略接口，定义了支付算法的统一接口。
• AlipayStrategy 和 WechatPayStrategy 是具体的支付策略类，分别实现了不同的支付算法。
• PaymentContext 是上下文类，根据传入的具体策略来执行相应的支付算法。

通过策略模式，客户端可以根据需要选择不同的支付策略，而不需要修改客户端代码，从而实现了算法的独立性和灵活性。

二、责任链模式

问题：什么是设计模式中的责任链模式？请举一个简单的例子

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合关系。请求沿着链传递，直到有一个对象处理它为止。

在责任链模式中，通常有以下角色：

1. 处理者接口（Handler Interface）：定义了处理请求的接口，通常包含一个方法用于设定下一个处理者的引用。

2. 具体处理者类（Concrete Handlers）：实现了处理者接口的具体处理者。在接收到请求后，如果能处理就处理；否则将请求传递给下一个处理者。

3. 客户端（Client）：创建责任链，并将请求发送到链中的第一个处理者。

下面是一个简单的例子，假设我们需要处理不同级别的折扣请求：

// 1. 处理者接口
interface DiscountHandler {
    void setNextHandler(DiscountHandler nextHandler);
    void applyDiscount(double discount);
}

// 2. 具体处理者类：初级会员折扣处理者
class JuniorMemberHandler implements DiscountHandler {
    private DiscountHandler nextHandler;

    @Override
    public void setNextHandler(DiscountHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void applyDiscount(double discount) {
        if (discount <= 0.1) {
            System.out.println("Applied " + discount*100 + "% discount for junior members.");
        } else if (nextHandler != null) {
            nextHandler.applyDiscount(discount);
        }
    }
}

// 具体处理者类：中级会员折扣处理者
class IntermediateMemberHandler implements DiscountHandler {
    private DiscountHandler nextHandler;

    @Override
    public void setNextHandler(DiscountHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void applyDiscount(double discount) {
        if (discount <= 0.2) {
            System.out.println("Applied " + discount*100 + "% discount for intermediate members.");
        } else if (nextHandler != null) {
            nextHandler.applyDiscount(discount);
        }
    }
}

// 具体处理者类：高级会员折扣处理者
class SeniorMemberHandler implements DiscountHandler {
    private DiscountHandler nextHandler;

    @Override
    public void setNextHandler(DiscountHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void applyDiscount(double discount) {
        if (discount <= 0.3) {
            System.out.println("Applied " + discount*100 + "% discount for senior members.");
        } else if (nextHandler != null) {
            nextHandler.applyDiscount(discount);
        }
    }
}

// 客户端
public class ChainOfResponsibilityPatternExample {
    public static void main(String[] args) {
        // 创建责任链：初级会员 -> 中级会员 -> 高级会员
        DiscountHandler juniorHandler = new JuniorMemberHandler();
        DiscountHandler intermediateHandler = new IntermediateMemberHandler();
        DiscountHandler seniorHandler = new SeniorMemberHandler();

        juniorHandler.setNextHandler(intermediateHandler);
        intermediateHandler.setNextHandler(seniorHandler);

        // 模拟不同折扣请求
        juniorHandler.applyDiscount(0.15); // 应该由中级会员处理
        juniorHandler.applyDiscount(0.05); // 由初级会员处理
        juniorHandler.applyDiscount(0.25); // 应该由高级会员处理
        juniorHandler.applyDiscount(0.35); // 没有合适的处理者，请求未处理
    }
}

在上面的例子中：

• DiscountHandler 是处理者接口，定义了处理折扣请求的方法 applyDiscount，并且有一个 setNextHandler 方法用于设定下一个处理者。
• JuniorMemberHandler、IntermediateMemberHandler 和 SeniorMemberHandler 是具体的折扣处理者类，分别处理不同级别的折扣请求。如果当前处理者无法处理请求，会将请求传递给下一个处理者。
• 在客户端中，创建了一个折扣处理责任链，并且模拟了不同折扣请求的处理情况。

通过责任链模式，我们可以动态地组织处理者的顺序，避免了请求发送者与接收者之间的直接耦合，提高了系统的灵活性和可维护性。

为者常成，行者常至