在软件工程中，设计模式是解决特定问题的成熟方案。它们是经过验证的模板，可以帮助开发者写出更清晰、更可维护的代码。今天，我们将探讨三种设计模式：状态模式、访问者模式和解释器模式，并通过实际业务场景来展示它们的应用。

状态模式（State Pattern）

定义：状态模式允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

业务场景：考虑一个在线购物平台，用户的订单状态会随着时间改变，比如从“未支付”变为“已支付”再到“已发货”。

实现：

java

public interface OrderState {
    void next(Order order);
}

public class UnpaidState implements OrderState {
    public void next(Order order) {
        order.setState(new PaidState());
        System.out.println("Order is now paid.");
    }
}

public class PaidState implements OrderState {
    public void next(Order order) {
        order.setState(new ShippedState());
        System.out.println("Order is now shipped.");
    }
}

public class ShippedState implements OrderState {
    public void next(Order order) {
        System.out.println("Order is already shipped.");
    }
}

public class Order {
    private OrderState state;

    public Order() {
        this.state = new UnpaidState();
    }

    public void setState(OrderState state) {
        this.state = state;
    }

    public void nextState() {
        state.next(this);
    }
}

访问者模式（Visitor Pattern）

定义：访问者模式允许你将算法与操作对象的结构分离，将处理过程封装在独立的类中。

业务场景：在电商平台中，我们可能需要对不同类型的商品进行不同的处理，比如计算价格、库存检查等。

实现：

java

public interface ProductVisitor {
    void visit(ProductA productA);
    void visit(ProductB productB);
}

public class TaxVisitor implements ProductVisitor {
    public void visit(ProductA productA) {
        System.out.println("Tax for ProductA: " + productA.getPrice() * 0.05);
    }

    public void visit(ProductB productB) {
        System.out.println("Tax for ProductB: " + productB.getPrice() * 0.10);
    }
}

public class ProductA {
    private double price;

    public ProductA(double price) {
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public void accept(ProductVisitor visitor) {
        visitor.visit(this);
    }
}

public class ProductB {
    private double price;

    public ProductB(double price) {
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public void accept(ProductVisitor visitor) {
        visitor.visit(this);
    }
}

解释器模式（Interpreter Pattern）

定义：解释器模式提供了一种评估语言的语法或表达式的方式。

业务场景：在一个简单的文本处理应用中，用户可以输入特定的命令来操作文本，比如“加粗”、“斜体”等。

实现：

java

public interface Expression {
    boolean interpret(String context);
}

public class AndExpression implements Expression {
    private Expression expr1;
    private Expression expr2;

    public AndExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    public boolean interpret(String context) {
        return expr1.interpret(context) && expr2.interpret(context);
    }
}

public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    public boolean interpret(String context) {
        return context.contains(data);
    }
}

// 使用
Expression expr = new AndExpression(new TerminalExpression("bold"), new TerminalExpression("italic"));
boolean result = expr.interpret("The text is bold and italic.");
System.out.println("Is the text bold and italic? " + result);

通过这些模式，我们可以看到如何将复杂的逻辑封装在可重用的组件中，从而提高代码的灵活性和可维护性。每种模式都有其适用场景，正确使用它们可以大大提升软件设计的质量。