策略模式实现与案例分析
策略模式:从《设计模式之禅》看如何优雅地解决问题
在软件开发中,设计模式是解决常见问题的模板,它提供了一种在特定场景下可以重复使用的解决方案。《设计模式之禅》这本书深入浅出地讲解了各种设计模式,帮助开发者更好地理解和应用这些模式。今天,我们将结合《设计模式之禅》的内容,探讨策略模式的实现方式,并通过多种案例来体现其灵活性和可扩展性。
什么是策略模式?
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。策略模式定义了一系列算法,并将每个算法封装起来,使它们可以互换。策略模式让算法独立于使用它的客户而变化。
策略模式的基本结构
策略模式包含以下角色:
- Context(上下文):持有一个策略类的引用。
- Strategy(策略):定义了一个算法族,每个算法都封装起来,使它们可以互换。
- ConcreteStrategy(具体策略):实现了Strategy接口,提供了具体的算法实现。
案例分析
案例1:促销策略
假设我们正在开发一个电商系统,系统中需要根据不同的促销策略来计算商品的最终价格。我们可以使用策略模式来实现这个功能。
代码实现
// 定义策略接口
public interface PromotionStrategy {
double calculatePrice(double originalPrice);
}
// 具体策略:满减策略
public class FullReductionStrategy implements PromotionStrategy {
private double threshold;
private double discount;
public FullReductionStrategy(double threshold, double discount) {
this.threshold = threshold;
this.discount = discount;
}
@Override
public double calculatePrice(double originalPrice) {
if (originalPrice >= threshold) {
return originalPrice - discount;
}
return originalPrice;
}
}
// 具体策略:打折策略
public class DiscountStrategy implements PromotionStrategy {
private double discountRate;
public DiscountStrategy(double discountRate) {
this.discountRate = discountRate;
}
@Override
public double calculatePrice(double originalPrice) {
return originalPrice * discountRate;
}
}
// 上下文
public class ShoppingCart {
private PromotionStrategy strategy;
public ShoppingCart(PromotionStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(PromotionStrategy strategy) {
this.strategy = strategy;
}
public double calculateFinalPrice(double originalPrice) {
return strategy.calculatePrice(originalPrice);
}
}
// 测试类
public class TestPromotion {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart(new FullReductionStrategy(100, 20));
System.out.println("满减后的价格: " + cart.calculateFinalPrice(120));
cart.setStrategy(new DiscountStrategy(0.8));
System.out.println("打折后的价格: " + cart.calculateFinalPrice(120));
}
}
案例2:支付方式
在电商系统中,用户可以选择不同的支付方式,如支付宝、微信支付、信用卡支付等。我们可以使用策略模式来实现这些支付方式。
代码实现
// 定义策略接口
public interface PaymentStrategy {
void pay(double amount);
}
// 具体策略:支付宝支付
public class AlipayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("使用支付宝支付: " + amount);
}
}
// 具体策略:微信支付
public class WechatPayStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("使用微信支付: " + amount);
}
}
// 具体策略:信用卡支付
public class CreditCardStrategy implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("使用信用卡支付: " + amount);
}
}
// 上下文
public class PaymentContext {
private PaymentStrategy strategy;
public PaymentContext(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(double amount) {
strategy.pay(amount);
}
}
// 测试类
public class TestPayment {
public static void main(String[] args) {
PaymentContext context = new PaymentContext(new AlipayStrategy());
context.executePayment(100);
context.setStrategy(new WechatPayStrategy());
context.executePayment(100);
context.setStrategy(new CreditCardStrategy());
context.executePayment(100);
}
}
策略模式的拓展
拓展1:动态加载策略
在实际应用中,我们可能需要动态加载策略类。Java提供了反射机制,可以实现这一功能。
代码实现
// 动态加载策略
public class DynamicStrategyLoader {
public static PaymentStrategy loadStrategy(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
Class<?> clazz = Class.forName(className);
return (PaymentStrategy) clazz.newInstance();
}
public static void main(String[] args) {
try {
PaymentStrategy strategy = DynamicStrategyLoader.loadStrategy("AlipayStrategy");
PaymentContext context = new PaymentContext(strategy);
context.executePayment(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
拓展2:使用策略模式实现排序算法
我们可以使用策略模式来实现不同的排序算法,如快速排序、冒泡排序等。
代码实现
// 定义策略接口
public interface SortStrategy {
void sort(int[] array);
}
// 具体策略:快速排序
public class QuickSortStrategy implements SortStrategy {
@Override
public void sort(int[] array) {
quickSort(array, 0, array.length - 1);
}
private void quickSort(int[] array, int low, int high) {
if (low < high) {
int pi = partition(array, low, high);
quickSort(array, low, pi - 1);
quickSort(array, pi + 1, high);
}
}
private int partition(int[] array, int low, int high) {
int pivot = array[high];
int i = (low - 1);
for (int j = low; j < high; j++) {
if (array[j] <= pivot) {
i++;
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
int temp = array[i + 1];
array[i + 1] = array[high];
array[high] = temp;
return i + 1;
}
}
// 具体策略:冒泡排序
public class BubbleSortStrategy implements SortStrategy {
@Override
public void sort(int[] array) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}
// 上下文
public class SortContext {
private SortStrategy strategy;
public SortContext(SortStrategy strategy) {
this.strategy = strategy;
}
public void setStrategy(SortStrategy strategy) {
this.strategy = strategy;
}
public void executeSort(int[] array) {
strategy.sort(array);
}
}
// 测试类
public class TestSort {
public static void main(String[] args) {
int[] array = {64, 34, 25, 12, 22, 11, 90};
SortContext context = new SortContext(new QuickSortStrategy());
context.executeSort(array);
System.out.println("快速排序后的数组: " + Arrays.toString(array));
context.setStrategy(new BubbleSortStrategy());
context.executeSort(array);
System.out.println("冒泡排序后的数组: " + Arrays.toString(array));
}
}
总结
策略模式是一种非常实用的设计模式,它可以帮助我们在运行时动态地改变对象的行为。通过《设计模式之禅》这本书,我们可以更深入地理解策略模式,并在实际项目中灵活应用。希望本文能帮助你更好地掌握策略模式,并在你的项目中发挥其优势。
以上就是本文的全部内容,希望对你有所帮助。如果你有任何问题或建议,欢迎在评论区留言。
扫一扫
2670
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
