Java设计模式-策略模式分析

最新推荐文章于 2024-03-01 09:59:47 发布
最新推荐文章于 2024-03-01 09:59:47 发布
阅读量2.6k 收藏 4
点赞数 5
分类专栏： java版常用设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011058616/article/details/108926840
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

策略模式


描述

博文简介

通过对策略模式的学习，消除程序中大量的冗余代码和多重条件转移语句。

策略模式的定义及应用场景

策略模式的定义
策略模式（Strategy Pattern）是指定义了算法家族、分别封装起来，让它们之间可以互 相替换，此模式让算法的变化不会影响到使用算法的用户。

策略模式的应用场景
1、假如系统中有很多类，而他们的区别仅仅在于他们的行为不同。
2、一个系统需要动态地在几种算法中选择一种。

策略模式实现

大家都知道，网络上的各种培训课程经常会有优惠活动，优惠策略会有很多种可能如：领取优惠券抵扣、返现促销、拼团优惠。下面我们用代码来模拟这种场景。
首先我们创建一 个促销策略的抽象PromotionStrategy：

/*** 促销策略抽象 */ 
public interface PromotionStrategy { 
	void doPromotion(); 
}

然后分别创建优惠券抵扣策略 CouponStrategy 类、返现促销策略 CashbackStrategy 类、拼团优惠策略 GroupbuyStrategy 类和无优惠策略 EmptyStrategy 类。
CouponStrategy 类：

/*** 优惠券 **/ 
public class CouponStrategy implements PromotionStrategy { 
	public void doPromotion() { 
		System.out.println("领取优惠券,课程的价格直接减优惠券面值抵扣"); 
	} 
}

CashbackStrategy 类：

/*** 返现活动 */ 
public class CashbackStrategy implements PromotionStrategy { 
	public void doPromotion() { 
		System.out.println("返现促销,返回的金额转到支付宝账号"); 
	} 
}

GroupbuyStrategy 类：

/*** 拼团优惠 */ 
public class GroupbuyStrategy implements PromotionStrategy{ 
	public void doPromotion() { 
		System.out.println("拼团，满 20 人成团，全团享受团购价"); 
	} 
}

EmptyStrategy 类：

/*** 无优惠 **/ 
public class EmptyStrategy implements PromotionStrategy { 
	public void doPromotion() { 
		System.out.println("无促销活动"); 
	} 
}

然后创建促销活动方案 PromotionActivity 类：

/*** 优惠活动 **/ 
public class PromotionActivity { 
	private PromotionStrategy promotionStrategy;
	public PromotionActivity(PromotionStrategy promotionStrategy) { 
		this.promotionStrategy = promotionStrategy; 
	}
	public void execute(){ 
		promotionStrategy.doPromotion(); 
	} 
}

编写客户端测试类：

public static void main(String[] args) { 
	PromotionActivity activity1 = new PromotionActivity(new CouponStrategy());
	PromotionActivity activity2 = new PromotionActivity(new CashbackStrategy()); 
	activity1.execute(); 
	activity2.execute(); 
}

此时，同学们会发现，如果把上面这段测试代码放到实际的业务场景其实会被骂。 因为我们做活动时候往往是要根据不同的需求对促销策略进行动态选择的，并不会一次性执行多种优惠。所以，我们的代码通常会这样写：

public static void main(String[] args) { 
	PromotionActivity promotionActivity = null; 
	String promotionKey = "COUPON"; 
	if(StringUtils.equals(promotionKey,"COUPON")){ 
		promotionActivity = new PromotionActivity(new CouponStrategy()); 
	}else if(StringUtils.equals(promotionKey,"CASHBACK")){ 
		promotionActivity = new PromotionActivity(new CashbackStrategy()); 
	}
	//此处偷懒...... 
	promotionActivity.execute(); 
}

这样改造之后，满足了业务需求，客户可根据自己的需求选择不同的优惠策略了。但是， 经过一段时间的业务积累，我们的促销活动会越来越多。于是，我们的程序猿天天加班凌晨都很吃力了，每次上活动之前都要通宵改代码，而且要做重复测试，判断逻辑可能也变得越来越复杂，梳理起来也变得非常棘手。这时候，我们就需要思考代码应该重构了，具体怎么操作呢，最终结合经验我们发现可以结合单例模式和工厂模式。
创建 PromotionStrategyFactory 类：

/*** 促销策略工厂 **/ 
public class PromotionStrategyFactory { 
	private static Map<String,PromotionStrategy> PROMOTION_STRATEGY_MAP = new HashMap<String, PromotionStrategy>(); 
	static { 
		PROMOTION_STRATEGY_MAP.put(PromotionKey.COUPON,new CouponStrategy()); 
		PROMOTION_STRATEGY_MAP.put(PromotionKey.CASHBACK,new CashbackStrategy()); 
		PROMOTION_STRATEGY_MAP.put(PromotionKey.GROUPBUY,new GroupbuyStrategy()); 
	}
	private static final PromotionStrategy NON_PROMOTION = new EmptyStrategy(); 
	private PromotionStrategyFactory(){} 
	public static PromotionStrategy getPromotionStrategy(String promotionKey){ 
		PromotionStrategy promotionStrategy = PROMOTION_STRATEGY_MAP.get(promotionKey); 
		return promotionStrategy == null ? NON_PROMOTION : promotionStrategy; 
	}
	private interface PromotionKey{ 
		String COUPON = "COUPON"; 
		String CASHBACK = "CASHBACK"; 
		String GROUPBUY = "GROUPBUY"; 
	} 
}

这时候我们客户端代码就应该这样写：

public static void main(String[] args) { 
	String promotionKey = "GROUPBUY"; 
	PromotionActivity promotionActivity = new PromotionActivity(PromotionStrategyFactory.getPromotionStrategy(promotionKey)); 
	promotionActivity.execute(); 
}

代码优化之后，是不是我们作为加班猿的概率就又降低了一点，每次上新活动，不影响原来的代码逻辑。效率大大的提高了。

选择支付方式的业务场景

为了加深对策略模式的理解，我们再来举一个案例。相信小伙伴们都 用过支付宝、微信支付、银联支付以及京东白条。一个常见的应用场景就是大家在下单 支付时会提示选择支付方式，如果用户未选，系统也会默认好推荐的支付方式进行结算。 下面我们用策略模式来模拟此业务场景：
创建 Payment 抽象类，定义支付规范和支付逻辑，代码如下：

/*** 支付渠道 **/ 
public abstract class Payment { 
	//支付类型 
	public abstract String getName(); 
	//查询余额 
	protected abstract double queryBalance(String uid); 
	//扣款支付 
	public PayState pay(String uid,double amount) { 
		if(queryBalance(uid) < amount){ 
			return new PayState(500,"支付失败","余额不足"); 
		}
		return new PayState(200,"支付成功","支付金额：" + amount); 
	} 
}

分别创建具体的支付方式
京东白条 JDPay 类：

public class JDPay extends Payment { 
	public String getName() { 
		return "京东白条"; 
	}
	protected double queryBalance(String uid) { 
		return 600; 
	} 
}

支付宝 AliPay 类：

public class AliPay extends Payment { 
	public String getName() { 
		return "支付宝"; 
	}
	protected double queryBalance(String uid) { 
		return 1000; 
	} 
}

微信支付 WechatPay 类：

public class WechatPay extends Payment { 
	public String getName() { 
		return "微信支付"; 
	}
	protected double queryBalance(String uid) { 
		return 300; 
	} 
}

银联支付 UnionPay 类：

public class UnionPay extends Payment { 
	public String getName() { 
		return "银联支付"; 
	}
	protected double queryBalance(String uid) { 
		return 150; 
	} 
}

创建支付状态的包装类 PayState:

/*** 支付完成以后的状态 **/ 
public class PayState { 
	private int code; 
	private Object data; 
	private String msg; 
	
	public PayState(int code, String msg,Object data) { 
		this.code = code; 
		this.data = data; 
		this.msg = msg; 
	} 
	
	public String toString(){ 
		return ("支付状态：[" + code + "]," + msg + ",交易详情：" + data); 
	} 
}

创建支付策略管理类PayStrategy：

/*** 支付策略管理 **/ 
public class PayStrategy { 
	public static final String ALI_PAY = "AliPay"; 
	public static final String JD_PAY = "JdPay"; 
	public static final String UNION_PAY = "UnionPay"; 
	public static final String WECHAT_PAY = "WechatPay"; 
	public static final String DEFAULT_PAY = ALI_PAY; 
	private static Map<String,Payment> payStrategy = new HashMap<String,Payment>(); 
	
	static { 
		payStrategy.put(ALI_PAY,new AliPay()); 
		payStrategy.put(WECHAT_PAY,new WechatPay()); 
		payStrategy.put(UNION_PAY,new UnionPay()); 
		payStrategy.put(JD_PAY,new JDPay()); 
	}
	
	public static Payment get(String payKey){ 
		if(!payStrategy.containsKey(payKey)){ 
			return payStrategy.get(DEFAULT_PAY); 
		}
		return payStrategy.get(payKey); 
	} 
}

创建订单 Order 类：

public class Order { 
	private String uid; 
	private String orderId; 
	private double amount; 
	public Order(String uid,String orderId,double amount){ 
		this.uid = uid; 
		this.orderId = orderId; 
		this.amount = amount; 
	}
	//完美地解决了 switch 的过程，不需要在代码逻辑中写 switch 了 
	//更不需要写 if else if 
	public PayState pay(){ 
		return pay(PayStrategy.DEFAULT_PAY); 
	}
	public PayState pay(String payKey){ 
		Payment payment = PayStrategy.get(payKey); 
		System.out.println("欢迎使用" + payment.getName()); 
		System.out.println("本次交易金额为：" + amount + "，开始扣款..."); 
		return payment.pay(uid,amount); 
	} 
}

编写测试代码：

public class PayStrategyTest { 
	public static void main(String[] args) { 
	//省略把商品添加到购物车，再从购物车下单 
	//直接从点单开始 
	Order order = new Order("1","20201005001000009",300.99); 
	//开始支付，选择微信支付、支付宝、银联卡、京东白条、财付通 
	//每个渠道它支付的具体算法是不一样的
	//基本算法固定的 
	//这个值是在支付的时候才决定用哪个值 
	System.out.println(order.pay(PayStrategy.ALI_PAY)); 
	} 
}

这里通过大家比较熟悉的业务场景来举例，让同学们更深刻地理解策略模式。希望大家在以后的工作体现出自己的优势。

策略模式在 JDK 源码中的体现

首先来看一个比较常用的比较器 Comparator 接口，我们看到的一个大家常用的 compare()方法，就是一个策略抽象实现：

public interface Comparator<T> { 
	int compare(T o1, T o2); 
	
	... 

}

Comparator抽象下面有非常多的实现类，我们经常会把Comparator作为参数传入作为排序策略，例如 Arrays类的parallelSort方法等：

public class Arrays { 

	... 
	
	public static <T> void parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp) { 
	
	... 
	
	}
	
	... 

}

还有TreeMap的构造方法:

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable { 

	...
	
	public TreeMap(Comparator<? super K> comparator) { 
		this.comparator = comparator; 
	}
	
	... 

}

策略模式的优缺点

优点：
1、策略模式符合开闭原则。
2、避免使用多重条件转移语句，如 if…else…语句、switch 语句
3、使用策略模式可以提高算法的保密性和安全性。
缺点：
1、客户端必须知道所有的策略，并且自行决定使用哪一个策略类。
2、代码中会产生非常多策略类，增加维护难度。

devil farmers
关注
专栏目录
Java行为型设计模式-策略模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-14 1078
Java策略模式（Strategy Pattern）是一种行为型设计模式，‌它允许你在运行时改变对象的行为，而不改变其结构。这种模式的核心思想是将算法或行为封装在不同的对象中，然后让客户端在运行时选择合适的策略来执行。‌这种模式使得算法可以独立于使用它的客户端变化，‌从而增强了系统的灵活性和可维护性。‌// 定义策略接口综上，策略模式是一种行为型设计模式，‌它允许你在运行时改变对象的行为。‌这种模式的核心思想是将一系列可互换的算法封装成独立的策略类，‌并在运行时根据需要选择使用哪个策略。‌。
Java设计模式-行为型设计模式-观察者模式
Fatter$hday的博客
05-09 1388
Java设计模式-行为型设计模式-观察者模式
策略模式实现多种支付方式
dsy__的博客
01-10 512
*策略上下文角色** PayStrategyFactory：策略上下文，负责和具体的策略实现交互，通常策略上下文对象会持有一个真正的策略实现对象，策略上下文还可以让具体的策略实现从其中获取相关数据，回调策略上下文对象的方法。System.out.println("用户选择 支付宝 支付，订单号为：" + orderId + " ，支付金额：" + amount);System.out.println("用户选择 京东 支付，订单号为：" + orderId + " ，支付金额：" + amount);
JAVA23种设计模式全面解析
十一的博客
05-17 539
23种设计模式全解析 一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种： 工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 工厂方法模式（Factory Method） 简单工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到工厂方法模式，创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。 抽象工
JAVA设计模式详解
woaini886353的博客
04-27 731
Java设计模式 目录 设计模式 3 1.1 创建型模式 4 1.1.1 工厂方法 4 1.1.2 抽象工厂 6 1.1.3 建造者模式 10 1.1.4 单态模式 13 1.1.5 原型模式 15 1.2 结构型模式 17 1.2.1 适配器模式 17 1.2.2 桥接模式 19 1.2.3 组合模式 23 1.2.4 装饰模式 26 1.2.5 外观模式 29 1.2.6 享元模式 32 1.2.7 代理模式 34 1.3 行为型模式 37 1.3.1 责任链模式 37 1.3.2 命令模式 40
Java设计模式：命令模式学习与分析
qq_16118409的博客
05-29 217
1.要点 命令模式将请求封装成对象，这可以让你使用不同的请求，队列，或者日志请求来参数化其他对象。命令模式也支持撤销操作。 命令模式将发出请求的对象和执行请求的对象解耦。 在被解耦的两者之间是通过命令对象进行沟通的。命令对象封装了接收者和一个（组）动作。 调用者通过调用命令对象的execute()发出请求，这会使得接收者的动作被调用。 调用者可以接受命令当做参数，甚至在运行时动态地进行。 命令可以支持撤销，做法是实现一个undo()方法来回到execute()被执行前的状态。 宏命令是命令的一种简单的延伸
使用注解 + 策略模式，减少代码中的if/switch语句，增加代码灵活性
微信公众号：一颗向上的草莓
06-30 1423
需求描述 现在我们有一个接受供应商订单状态通知的接口，目前支持的功能有退款，改签，后续可能需要接入新功能，比如航变，订单状态改变之类。接口的请求格式一致，接口如下： 基本解决方案：使用switch或if 请求 package com.ahut.contract.flight; /** * @desc : 供应商通知请求 * @author : cheng * @date : 201...
JAVA设计模式-设计模式公司出品
08-04
JAVA设计模式是编程领域中非常重要的概念，它为软件开发人员提供了在特定情境下解决常见问题的模板。设计模式公司出品的《JAVA设计模式》书籍，详细介绍了多种设计模式，适合不同水平的程序员学习和使用。 首先，...
JAVA模式设计-策略模式
u010451990的专栏
05-28 367
面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。 首先强调一个概念抽象类 一.抽象类　　在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：1 abstract void fun(); 　　抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，
java设计模式-策略模式
qq_41035592的博客
09-22 203
策略模式 策略模式是指有一定行动内容的相对稳定的策略名称。策略模式在古代中又称“计策”，简称“计”，如《汉书·高帝纪上》：“汉王从其计”。这里的“计”指的就是计谋、策略。策略模式具有相对稳定的形式，如“避实就虚”、“出奇制胜”等。一定的策略模式，既可应用于战略决策，也可应用于战术决策；既可实施于大系统的全局性行动，也可实施于大系统的局部性行动。 什么时候使用？ 1、如果在一个系统里面有许多类，它们...
java设计模式之策略模式
weixin_44111797的博客
10-31 220
1.策略模式 故事背景: 刘备要到江东娶老婆了，走之前诸葛亮给赵云（伴郎）三个锦囊妙计，说是按机拆开 解决棘手问题，嘿，还说，真是解决了大问题，搞到最后是周瑜陪了人又折兵呀，那咱 们先看看这个场景是什么样子的。 先说这个场景中的要素：三个妙计，一个锦囊，一个赵云，妙计是小亮同志给的，妙计 是放置在锦囊里，俗称就是锦囊妙计嘛，那赵云就是一个干活的人，从锦囊中取出妙计，执 行，然后获胜，用 JAVA 程序怎么表现这个呢？ 三个妙计是同一类型的东东，那咱就写个接口： public interface IStr
策略模式+工厂模式替代if-else实现会员折扣价转换
qq_44813449的博客
04-02 218
无意中了解到策略模式可以替代繁杂而又臃肿的if-else逻辑判断。所以就研究了一下。策略模式是一个简单容易理解的设计模式之一。 首先。创建一个策略接口，以便于其他策略实现类继承该接口。我们这里以会员等级来获取不同折扣为例： public interface Strange { double getDiscount(); } 然后，实现各种不同的策略，我这里分为三种： 1级会员原价； 2级会员8折； 3级会员6折； public class Vip1Price implements Strang
策略模式：优化函数行为，减少if else的使用频率。
性感的小君君
04-10 553
文章目录一、策略模式介绍二、注意事项三、C语言代码示例1. 源码2. 运行结果四、java的代码示例五、C++的代码示例六、pyhton的代码示例 一、策略模式介绍 策略模式（Strategy Pattern） 是属于设计模式中的 行为模式 中的一种，关注的是对象之间通信的方式。 策略模式主要解决选项过多的问题，避免大量的if else 和 switch下有太多的case c语言主要通过函数指针来实现， java pytho等面向对象的语言主要是通过 多态和函数重载 来完成的。 在策略模式（Stra
JAVA设计模式之策略模式---支付
2201_75287416的博客
09-27 295
中的标识符来获取相应的 Spring Bean 实例，使得你可以动态选择并获取不同的服务组件实例，而不需要显式地创建对象。注：这里的支付并不是支付方式（微信，支付宝）而是根据业务来的不同支付节点，比如定金（预付款）运费，尾款根据不同的支付节点处理不同的业务逻辑。=====================那么策略模式的大体结构就是这样======================下面这个接口就相当于类图中Strategy（策略类），支持所有的公共接口。在本文末尾会比较策略模式与工厂模式和装饰者模式的区别。
策略模式-java实现
最新发布
qq_45653382的博客
03-01 989
以支付为例，用户在支付商品时，可以有多种支付方式，如支付宝，微信，现金。当支付方式增多，支付策略复杂化，我们就要考虑使用策略模式，这样可以避免if else 成堆出现，既不美观也很容易出错。通过枚举的ordinal 我们知道AlPay是0，WxPay是1，CashPay是2，我们就建立了一对一关系，只要给我数字这里就可以通过getPayTypeEnum()返回对应的枚举。通过Map的get方法提供Bean的名字，获取对应的支付现实类。实现支付接口(不同的支付方式有不同的策略)接收支付类型和支付金额。
java设计模式--适配器设计
03-21
总结来说，适配器设计模式是Java中解决接口不兼容问题的关键策略，它使得原本无法协作的类能够协同工作，提高了代码的复用性和灵活性。在理解和掌握了适配器模式后，开发者可以更好地应对各种接口不匹配的问题，提升...
Java的策略模式
朱哥的博客
08-24 190
今天难得母亲大人休息，跟外婆妹妹她们一起去喝早茶，本来是很平常的一餐，但当结账时我看到了餐厅上写的打折优惠（具体部分没有拍照，大致是下面这样子），心里若有所思，觉得跟 Java 的策略模式很相像。
用一个支付案例带你理解策略模式（模拟不同的支付）
lp18871701190的博客
08-21 1318
首先创建一个支付渠道的抽象类 package paymethod; /** * 支付通道 * @author lp */ public abstract class PayAccess { //支付类型的抽象方法 public abstract String getName(); //查询余额的抽象方法 protected abstract doub...
Java设计模式 | 基于订单批量支付场景，对策略模式和简单工厂模式进行简单实现
程序员雅痞的博客
10-19 1414
使用策略模式+简单工厂模式 模拟批量支付场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值