详解Java如何优雅的使用策略模式

策略模式（Strategy Pattern）属于行为型设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以互换。策略模式让算法的变化独立于使用算法的客户端，客户端通过传递不同的策略对象来使用不同的算法。

在Java里，策略模式的实现有很多种方法，接下来将说明其中一种优雅的实现方式。

1. 定义接口和实现策略

首先，我们定义一个接口来作为策略的基础，并让不同的策略实现这个接口，如下所示：

public interface Strategy {
    int execute(int num1, int num2);
}

public class AddStrategy implements Strategy {
    @Override
    public int execute(int num1, int num2) {
        return num1 + num2;
    }
}

public class SubtractStrategy implements Strategy {
    @Override
    public int execute(int num1, int num2) {
        return num1 - num2;
    }
}

这里定义了一个Strategy接口，包含一个execute方法用于执行算法。接着，我们实现了两个具体的策略：AddStrategy和SubtractStrategy。

2. 如何使用策略

接下来，我们就可以使用策略了。

public class Calculator {
    private Strategy strategy;

    public Calculator(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.execute(num1, num2);
    }

    public static void main(String[] args) {
        Calculator calculator;
        int num1 = 10;
        int num2 = 5;

        calculator = new Calculator(new AddStrategy());
        int sum = calculator.executeStrategy(num1, num2);
        System.out.println("Sum = " + sum);

        calculator = new Calculator(new SubtractStrategy());
        int difference = calculator.executeStrategy(num1, num2);
        System.out.println("Difference = " + difference);
    }
}

这里定义了一个Calculator类，它需要一个Strategy对象来执行算法。在构造函数中，我们传入一个具体的策略对象，然后在executeStrategy方法中调用它的execute方法来执行算法。在main方法中，我们定义了两个数字，并实例化了一个Calculator对象。当我们需要使用不同的算法时，只需要将不同的策略对象传递给Calculator对象即可。

3. 示例1：在线支付的策略模式实现

实际应用中，策略模式经常用于实现在线支付的多种支付方式。

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

public class CreditCardStrategy implements PaymentStrategy {
    private String name;
    private String cardNumber;
    private String cvv;
    private String expiryDate;

    public CreditCardStrategy(String name, String cardNumber, String cvv, String expiryDate) {
        this.name = name;
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.expiryDate = expiryDate;
    }

    @Override
    public void pay(double amount) {
        System.out.println(amount + " paid with credit/debit card.");
    }
}

public class PayPalStrategy implements PaymentStrategy {
    private String emailId;
    private String password;

    public PayPalStrategy(String emailId, String password) {
        this.emailId = emailId;
        this.password = password;
    }

    @Override
    public void pay(double amount) {
        System.out.println(amount + " paid using PayPal.");
    }
}

public class ShoppingCart {
    private List<Item> items;

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

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

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

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

    public void pay(PaymentStrategy paymentMethod) {
        double amount = calculateTotal();
        paymentMethod.pay(amount);
    }
}

public class Item {
    private String name;
    private double price;

    public Item(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

这里定义了PaymentStrategy接口，并实现了两个具体的策略：CreditCardStrategy和PayPalStrategy。接着，我们定义了ShoppingCart类和Item类。在ShoppingCart类中，我们包含一个pay方法，使用传入的策略对象来支付购物车内商品的总价格。这个示例使用了聚合关系将Item对象添加到ShoppingCart对象中。

4. 示例2：图形绘制的策略模式实现

另一个示例是使用策略模式来实现图形绘制应用程序中的不同绘制算法。

public interface DrawStrategy {
    void draw();
}

public class DrawLineStrategy implements DrawStrategy {
    @Override
    public void draw() {
        System.out.println("绘制直线");
    }
}

public class DrawCircleStrategy implements DrawStrategy {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class GraphEditor {
    private DrawStrategy drawStrategy;

    public void setDrawStrategy(DrawStrategy drawStrategy) {
        this.drawStrategy = drawStrategy;
    }

    public void draw() {
        drawStrategy.draw();
    }
}

public class Client {
    public static void main(String[] args) {
        GraphEditor editor = new GraphEditor();
        editor.setDrawStrategy(new DrawLineStrategy());
        editor.draw();

        editor.setDrawStrategy(new DrawCircleStrategy());
        editor.draw();
    }
}

这里定义了DrawStrategy接口，并实现了两个具体的策略：DrawLineStrategy和DrawCircleStrategy。接着，我们定义了GraphEditor类，它包含一个DrawStrategy对象并使用这个对象来绘制图形。最后，在客户端中，我们实例化了GraphEditor对象，并分别设置了DrawLineStrategy和DrawCircleStrategy作为绘制策略。

总结

策略模式是一种灵活的、可重用的设计模式，它可以让我们在不修改客户端代码的情况下，使用不同的算法来处理相似的问题。本文介绍了Java中优雅的实现策略模式的方法，并提供了两个具体的示例：实现在线支付的策略模式和图形绘制的策略模式。