【Java Switch Case设计模式实战】：策略模式与状态模式的应用

# 1. Java Switch Case设计模式概述

Java中的switch-case语句是决策控制结构，允许基于不同的条件执行不同的代码块。尽管switch-case在结构上看起来并不像传统意义上的设计模式，但它在编写可读性强、维护简单的代码时，可以作为一种模式或策略来考虑。本文将探讨switch-case如何通过灵活的应用，实现类似于策略模式和状态模式的行为。

## switch-case语句的基本使用

switch-case是许多编程语言中常用的控制结构，它根据表达式的值跳转到不同的执行路径。下面是一个简单的Java switch-case示例：

int value = 2;
switch (value) {
    case 1:
        System.out.println("Value is one");
        break;
    case 2:
        System.out.println("Value is two");
        break;
    case 3:
        System.out.println("Value is three");
        break;
    default:
        System.out.println("Value is not one, two, or three");
}

在上述代码中，根据变量`value`的值，程序输出不同的信息。使用switch-case可以使得多条件判断更加清晰和简洁。

## switch-case在策略模式中的角色

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响到使用算法的客户端。在策略模式中，switch-case可以作为动态选择策略的一种简便方法。例如：

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
    }
}

public class Context {
    Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void executeStrategy() {
        strategy.execute();
    }
}

// 在客户端代码中使用switch-case来选择策略
Strategy strategy = null;
switch (someCondition) {
    case "A":
        strategy = new ConcreteStrategyA();
        break;
    case "B":
        strategy = new ConcreteStrategyB();
        break;
}
Context context = new Context(strategy);
context.executeStrategy();

在这个例子中，根据某个条件（如`someCondition`），程序通过switch-case动态地选择并应用不同的策略。

接下来的章节将深入探讨策略模式和状态模式的原理与实现，并且展示如何将switch-case与这些模式结合，以优化代码结构和提升可维护性。

# 2. 策略模式的原理与实现

策略模式是一种行为设计模式，它允许在运行时选择算法的行为。这种模式将算法的定义与使用算法的客户端代码解耦，从而使算法可以灵活地被替换，而不需要修改客户端代码。

## 策略模式基本概念

### 策略模式定义与组成

策略模式定义了一组算法，将每个算法都封装起来，并使它们可以互换。策略模式让算法的变化独立于使用算法的客户。该模式涉及三种角色：

1. **上下文(Context)**：持有一个策略的引用，最终负责算法的执行。
2. **策略(Strategy)**：定义算法的接口，各种不同的算法都实现这个接口。
3. **具体策略(Concrete Strategies)**：实现了策略接口的具体算法类。

### 策略模式的UML类图解析

为了更好地理解策略模式的结构，我们可以参考以下UML类图：

![策略模式UML类图](***

***：具有一个接口成员变量，指向策略接口，可以设置和获取策略对象。
- **Strategy**：策略接口，定义了一个执行策略的方法。
- **ConcreteStrategyA** 和 **ConcreteStrategyB**：实现策略接口的两个具体策略类，分别实现策略接口中定义的方法。

## 策略模式在实际中的应用

### 策略模式的使用场景分析

策略模式适用于以下场景：

1. **算法需要自由切换的情况**：当算法需要根据不同情况来选择不同的算法时，策略模式能够提供多种算法实现供选择。
2. **避免多重条件选择语句**：当一个类有多个行为，并且这些行为是根据不同条件做出的选择时，使用策略模式可以将这些条件分支替换为策略对象的多态调用。
3. **对客户隐藏具体策略的实现细节**：使用策略模式可以让客户端仅仅通过策略接口来指定使用哪个算法，而不必关心算法的具体实现。

### 策略模式的代码实现

下面展示一个简单的策略模式实现，用于支付方式的选择。

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

// 具体策略：信用卡支付
public class CreditCardStrategy implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;

    public CreditCardStrategy(String nm, String ccNum, String cvv, String expiryDate) {
        this.name = nm;
        this.cardNumber = ccNum;
        this.cvv = cvv;
        this.dateOfExpiry = expiryDate;
    }
    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid with credit/debit card");
    }
}

// 具体策略：COD
public class CashOnDeliveryStrategy implements PaymentStrategy {
    private String name;
    public CashOnDeliveryStrategy(String nm) {
        this.name = nm;
    }
    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid with cash on delivery");
    }
}

// 上下文
public class ShoppingCart {
    private List<Item> items;
    private PaymentStrategy paymentStrategy;

    public ShoppingCart() {
        this.items = new ArrayList<>();
    }

    public void addItem(Item item) {
        this.items.add(item);
    }

    public void removeItem(Item item) {
        this.items.remove(item);
    }

    public int calculateTotal() {
        int sum = 0;
        for(Item item : items) {
            sum += item.getPrice();
        }
        return sum;
    }

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void pay() {
        paymentStrategy.pay(this.calculateTotal());
    }
}

// 测试类
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Sho