【设计模式】策略模式的实现--------java

最新推荐文章于 2022-05-03 09:18:25 发布
最新推荐文章于 2022-05-03 09:18:25 发布
阅读量162 收藏
点赞数
分类专栏： 设计模式 java 笔记 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45289396/article/details/106088025
版权
笔记 同时被 3 个专栏收录
24 篇文章 0 订阅
订阅专栏
设计模式
23 篇文章 0 订阅
订阅专栏
java
22 篇文章 0 订阅
订阅专栏

策略模式（Strategy Pattern）

什么时候用策略模式：一个系统需要动态地在几种算法中方选择一种时。

1.银行收银软件（由单价、数量，向客户收费）

package computer;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Cash cash = new Cash();
		boolean flag = true;
		while (flag) {
			cash.buttonOK();
			if (cash.totalPrice > 10) {
				flag = false;
			}
		}
		System.out.println("=======================================");
		System.out.print("购物清单：" + "\n"+cash.list);
		System.out.println("总价：" + cash.totalPrice);
	}

}

class Cash {
	public String list = "";
	public double totalPrice = 0.00;

	public void buttonOK() {
		Scanner cin = new Scanner(System.in);
		System.out.print("请输入单价：");
		String price = cin.next();
		System.out.print("请输入数量：");
		String num = cin.next();
		double xiaoji = Double.parseDouble(price) * Integer.parseInt(num);
		// 清单
		list += "单价：" + price + "，数量：" + num + "，小计" + xiaoji + "\n";
		// 将每个小计计入总计
		totalPrice += xiaoji;
	}
}

问题：商场搞活动折扣不断变化，则程序也不断变化。
改进：输入折扣。

2.改进：（输入折扣）

package computer;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Cash cash = new Cash();
		boolean flag = true;
		while (flag) {
			cash.buttonOK();
			if (cash.totalPrice > 10) {
				flag = false;
			}
		}
		System.out.println("=======================================");
		System.out.print("购物清单：" + "\n" + cash.list);
		System.out.println("总价：" + cash.totalPrice);
	}

}

class Cash {
	public String list = "";
	public double totalPrice = 0.00;

	public void buttonOK() {
		Scanner cin = new Scanner(System.in);
		System.out.print("请输入单价：");
		String price = cin.next();

		System.out.print("请输入数量：");
		String num = cin.next();

		System.out.print("请输入所享折扣：");
		String zhekou = cin.next();

		double xiaoji = Double.parseDouble(price) * Integer.parseInt(num) * Double.parseDouble(zhekou);
		// 清单
		list += "单价：" + price + "，数量：" + num + "，折扣" + zhekou + "，小计" + xiaoji + "\n";
		// 将每个小计计入总计
		totalPrice += xiaoji;
	}
}

缺点：在添加满300减100的促销算法等程序会变得复杂。

3.改进：（用简单工厂模式）
一个父类 多个子类分别为打折子类、返利子类…再加工厂类
在这里插入图片描述

package computer;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		boolean flag=true;
		String list="";
		double totalPrice=0.00;
		
		while(flag) {
			System.out.print("请输入单价：");
			String price=cin.next();
			
			System.out.print("请输入数量：");
			String num=cin.next();
			
			System.out.print("请输入折扣类型（1无折扣 2打折 3 满减）：");
			String type=cin.next();
			
			double discount=0;
			double basePrice=0;
			double returnPrice=0;
			
			if(type.equals("2")) {
				System.out.print("请输入折扣：");
				discount=Double.parseDouble(cin.next());
			}
			
			if(type.equals("3")) {
				System.out.print("请输入返现基础金额：");
				basePrice=Double.parseDouble(cin.next());
				System.out.print("请输入返现金额：");
				returnPrice=Double.parseDouble(cin.next());
			}
			//单价*金额
			double xiaoji=Double.parseDouble(price)*Double.parseDouble(num);
			
			CashSuper cs=CashAcceptFactory.createCashAccept(type, discount, basePrice, returnPrice);
			//处理后的价格
			xiaoji=cs.acceptCash(xiaoji);
			list+="单价"+price+"，数量"+num+"，折扣"+discount+"，小计"+xiaoji+"\n";
			totalPrice+=xiaoji;
			
			if(totalPrice>10) {
				flag=false;
			}
		}
		
		System.out.println("=====================================================");
		System.out.print("清单：\n"+list);
		System.out.println("总价："+totalPrice);
	}

}

//抽象现金收取类
abstract class CashSuper{
	//抽象方法（参数为原价，返回当前价）
	public abstract double acceptCash(double money);
}

//正常收费类
class CashNormal extends CashSuper{
	public double acceptCash(double money) {
		return money;
	}
}

//打折收费类
class CashRebate extends CashSuper{
	private double discount=0.00;
	public CashRebate(double discount){
		this.discount=discount;
	}
	
	//继承的方法
	public double acceptCash(double money) {
		return money*discount;
	}

	public double getDiscount() {
		return discount;
	}
	public void setDiscount(double discount) {
		this.discount = discount;
	}
	
}

//返利收费类
class CashReturn extends CashSuper{
	//基础金额
	private double baseCash;
	//返现金额
	private double returnCash;

	//构造设置基础金额和返现金额
	public CashReturn(double baseCash, double returnCash) {
		this.baseCash = baseCash;
		this.returnCash = returnCash;
	}
	
	//继承的方法
	public double acceptCash(double money) {
		double result=money;
		if(money>baseCash) {
			result=money-Math.floor(money/baseCash)*returnCash;
		}
		return result;
	}

	public double getBaseCash() {
		return baseCash;
	}

	public void setBaseCash(double baseCash) {
		this.baseCash = baseCash;
	}

	public double getReturnCash() {
		return returnCash;
	}

	public void setReturnCash(double returnCash) {
		this.returnCash = returnCash;
	}
	
}

//现金收取工厂
class CashAcceptFactory{
	//根据参数生成相应的对象（类型，折扣，基础金额，返现金额）
	public static CashSuper createCashAccept(String type,double discount,double basePrice,double returnPrice) {
		CashSuper cs=null;
		if(type.equals("1"))
			cs=new CashNormal();
		else if(type.equals("2"))
			cs=new CashRebate(discount);
		else if(type.equals("3"))
			cs=new CashReturn(basePrice,returnPrice);
		return cs;
	}
}

缺点：每次增加减少收费方式的时候都要对工厂类进行改动，不符合开放封闭原则。

4.改进：（策略模式下的收费系统）
将根据type判断是那个收费类的职责交给客户端，即工厂类中不能出现具体的收费方法类，用它们的父类代替，并为其传入具体的收费方式对象。

package computer;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		CashSuper cs=null;
		boolean flag=true;
		String list="";
		double totalPrice=0.00;
		
		double price=0,num=0,discount=0;
		while(flag) {
			System.out.print("请输入单价：");
			price=Double.parseDouble(cin.next());
			
			System.out.print("请输入数量：");
			num=Double.parseDouble(cin.next());
			
			System.out.print("请输入折扣类型（1无折扣 2打折 3 满减）：");
			String type=cin.next();
			
			if(type.equals("1")) {
				cs=new CashNormal();
			}
			
			else if(type.equals("2")) {
				System.out.print("请输入折扣：");
				discount=Double.parseDouble(cin.next());
				cs=new CashRebate(discount);
			}
			
			else if(type.equals("3")) {
				System.out.print("请输入返现基础金额：");
				String basePrice=cin.next();
				System.out.print("请输入返现金额：");
				String returnPrice=cin.next();
				cs=new CashReturn(Double.parseDouble(basePrice),Double.parseDouble(returnPrice));
			}
			
			double xiaoji=price*num;
			CashAcceptFactory caf=new CashAcceptFactory(cs);
			
			xiaoji=caf.getResult(xiaoji);
			list+="单价"+price+"，数量"+num+"，折扣"+discount+"，小计"+xiaoji+"\n";
			totalPrice+=xiaoji;
			
			if(totalPrice>10)
				flag=false;
		}
		
		System.out.println("=====================================================");
		System.out.print("清单：\n"+list);
		System.out.println("总价："+totalPrice);
	}

}

//抽象现金收取类
abstract class CashSuper{
	//抽象方法（参数为原价，返回当前价）
	public abstract double acceptCash(double money);
}

//正常收费类
class CashNormal extends CashSuper{
	public double acceptCash(double money) {
		return money;
	}
}

//打折收费类
class CashRebate extends CashSuper{
	private double discount=0.00;
	
	public CashRebate(double discount){
		this.discount=discount;
	}
	
	//继承的方法
	public double acceptCash(double money) {
		return money*discount;
	}

	public double getDiscount() {
		return discount;
	}
	public void setDiscount(double discount) {
		this.discount = discount;
	}
	
}

//返利收费类
class CashReturn extends CashSuper{
	//基础金额
	private double baseCash;
	//返现金额
	private double returnCash;

	//构造设置基础金额和返现金额
	public CashReturn(double baseCash, double returnCash) {
		this.baseCash = baseCash;
		this.returnCash = returnCash;
	}
	
	//继承的方法
	public double acceptCash(double money) {
		double result=money;
		if(money>baseCash) {
			result=money-Math.floor(money/baseCash)*returnCash;
		}
		return result;
	}

	public double getBaseCash() {
		return baseCash;
	}

	public void setBaseCash(double baseCash) {
		this.baseCash = baseCash;
	}

	public double getReturnCash() {
		return returnCash;
	}

	public void setReturnCash(double returnCash) {
		this.returnCash = returnCash;
	}
	
}

//现金收取工厂
class CashAcceptFactory{
	//现金收费父类对象
	private CashSuper cs=null;
	//构造方法传入具体的收费类对象
	public CashAcceptFactory(CashSuper cs) {
		this.cs=cs;
	}
	//通过cs调用收费计算方法，得到收费结果
	public double getResult(double money) {
		return cs.acceptCash(money);
	}
}

此时若要增加收费方法，只需要添加新的具体收费类、修改客户端即可。

5.策略模式：
（与简单工厂类似）
在这里插入图片描述

package computer;

public class Test {
	public static void main(String[] args) {
		Context context;
		
		context=new Context(new ConcreteStrategyA());
		context.contextInterface();
		
		context=new Context(new ConcreteStrategyB());
		context.contextInterface();
		
		context=new Context(new ConcreteStrategyC());
		context.contextInterface();
	}
}

//所有算法的公共接口
abstract class Strategy{
	//抽象方法
	public abstract void algorithmInterface();
}

//具体算法A
class ConcreteStrategyA extends Strategy{
	//继承的方法
	public void algorithmInterface() {
		System.out.println("算法A实现。");
	}
}

//具体算法B
class ConcreteStrategyB extends Strategy{
	//继承的方法
	public void algorithmInterface() {
		System.out.println("算法B实现。");
	}
}

//具体算法C
class ConcreteStrategyC extends Strategy{
	//继承的方法
	public void algorithmInterface() {
		System.out.println("算法C实现。");
	}
}

//工厂
class Context{
	//抽象类对象
	Strategy strategy;

	//构造方法初始化抽象类对象
	public Context(Strategy strategy) {
		this.strategy = strategy;
	}
	
	//调用具体策略对象的方法的方法
	public void contextInterface() {
		strategy.algorithmInterface();
	}
}

简单工厂模式与策略模式的对比：
简单工厂模式中用户在使用的是工厂类返回的类
策略模式中用户使用的是工厂类

优点：拓展性好、符合开放封闭原则。
缺点：分支判断放回客户端，改变需求算法时，还是要修改客户端。所有策略类都对外暴露。

6.策略模式与简单工厂结合：
解决：其他都不变，改变工厂类，将分支判断放到工厂类中。

package computer;

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		CashSuper cs=null;
		boolean flag=true;
		String list="";
		double totalPrice=0.00;
		
		double price=0,num=0,discount=0;
		while(flag) {
			System.out.print("请输入单价：");
			price=Double.parseDouble(cin.next());
			
			System.out.print("请输入数量：");
			num=Double.parseDouble(cin.next());
			
			double xiaoji=price*num;
			CashContext cc=new CashContext();
			
			xiaoji=cc.getResult(xiaoji);
			list+="单价"+price+"，数量"+num+"，折扣"+discount+"，小计"+xiaoji+"\n";
			totalPrice+=xiaoji;
			
			if(totalPrice>10)
				flag=false;
		}
		
		System.out.println("=====================================================");
		System.out.print("清单：\n"+list);
		System.out.println("总价："+totalPrice);
	}

}

//抽象现金收取类
abstract class CashSuper{
	//抽象方法（参数为原价，返回当前价）
	public abstract double acceptCash(double money);
}

//正常收费类
class CashNormal extends CashSuper{
	public double acceptCash(double money) {
		return money;
	}
}

//打折收费类
class CashRebate extends CashSuper{
	private double discount=0.00;
	
	public CashRebate(double discount){
		this.discount=discount;
	}
	
	//继承的方法
	public double acceptCash(double money) {
		return money*discount;
	}

	public double getDiscount() {
		return discount;
	}
	public void setDiscount(double discount) {
		this.discount = discount;
	}
	
}

//返利收费类
class CashReturn extends CashSuper{
	//基础金额
	private double baseCash;
	//返现金额
	private double returnCash;

	//构造设置基础金额和返现金额
	public CashReturn(double baseCash, double returnCash) {
		this.baseCash = baseCash;
		this.returnCash = returnCash;
	}
	
	//继承的方法
	public double acceptCash(double money) {
		double result=money;
		if(money>baseCash) {
			result=money-Math.floor(money/baseCash)*returnCash;
		}
		return result;
	}

	public double getBaseCash() {
		return baseCash;
	}

	public void setBaseCash(double baseCash) {
		this.baseCash = baseCash;
	}

	public double getReturnCash() {
		return returnCash;
	}

	public void setReturnCash(double returnCash) {
		this.returnCash = returnCash;
	}
	
}

//现金收取工厂
class CashContext{
	//现金收费父类对象
	private CashSuper cs=null;
	
	//构造方法分支判断
	public CashContext() {
		Scanner cin=new Scanner(System.in);
		System.out.print("请输入折扣类型（1无折扣 2打折 3 满减）：");
		String type=cin.next();
		
		double discount=0;
		double basePrice=0;
		double returnPrice=0;
		
		if(type.equals("1")) {
			cs=new CashNormal();
		}
		
		else if(type.equals("2")) {
			System.out.print("请输入折扣：");
			discount=Double.parseDouble(cin.next());
			cs=new CashRebate(discount);
		}
		
		else if(type.equals("3")) {
			System.out.print("请输入返现基础金额：");
			basePrice=Double.parseDouble(cin.next());
			System.out.print("请输入返现金额：");
			returnPrice=Double.parseDouble(cin.next());
			cs=new CashReturn(basePrice,returnPrice);
		}
	}
	
	//通过cs调用收费计算方法，得到收费结果
	public double getResult(double money) {
		return cs.acceptCash(money);
	}
}

当增加新地收费方法时，只需要添加新的具体收费类、修改工厂类构造函数即可。

简单工厂类地客户端需要知道两个类：收费父类和工厂类；
与简单工厂模式结合的策略模式的客户端只需要认识一个类：工厂类。不需要认识父类，降低模块之间的耦合度。

WENWENlll
关注
专栏目录
设计模式学习笔记（30）——策略模式实现
Aurora__213的博客
06-13 248
一、商场收银软件 商场收银软件，营业员根据顾客所购买的商品的单价和数量，向客户收费。 package operation; import java.util.Scanner; class Cash{ public String list=""; public Double totalPrice=0.0d; public void buttonOK() { Scanner sc=new Scanner(System.in); System.out.println("输入单价："); St
Java设计模式（一） 策略模式
weixin_34343308的博客
11-21 88
策略模式：定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。 1，定义算法接口 package com.pattern.strategy.test; public interface MoveBehavior { public void move(); } 2，定义算法的实现类 下面是三个算法的实现类 a, MoveFast...
设计模式-策略模式 实现
weixin_30457551的博客
02-28 64
策略模式： 　　定义了算法族，将算法分别封装起来，让他们相互之间可以相互替换，该模式使得算法独立于客户。 定义个一个animal父类 public abstract class Animal { public Color color; //公共行为 public void live() { System.out.p...
设计模式： 策略模式的实现
Arvon
08-24 598
1.    策略模式:定义了算法族，分别封装起来，让它们之间可以替换，此模式让算法的变化独立于使用该算法的用户。（利用组合） 类图如下:   源代码如下： package Strategy; /** * 鸭子超类 * @author Arvon * */ public abstract class Duck { public Duck() { su
设计模式之实现---策略模式
aolan7349的博客
11-06 92
/**************************************************************** CCharactor.h ****************************************************************/ #pragma once#include "CWeapon.h" ////////////...
java实现策略模式-设计模式
06-14
策略模式通过定义一组可互换的算法（即策略），将每个算法封装成相应的策略类。这样客户端可以根据需要选择不同的策略，并且能够灵活地切换和扩展策略，而不需要修改原有的代码逻辑。策略模式能够提高代码的灵活性、...
参考文档-23种JAVA设计模式和15种J2EE设计模式.zip
03-28
本资源“参考文档-23种JAVA设计模式和15种J2EE设计模式.zip”包含了Java语言和J2EE平台下广泛使用的设计模式，旨在帮助开发者提升软件设计能力，实现更加高效、灵活和可维护的代码。 首先，我们关注Java的23种经典...
JAVA-设计模式-行为型模式-策略模式
最新发布
08-10
JAVA-设计模式-行为型模式-策略模式
计算机后端-Java-图解java设计模式143 策略模式(4)-Arr.avi
05-23
计算机后端-Java-图解java设计模式143 策略模式(4)-Arr.avi
gof-java-design-patterns:Java示例中所有GOF设计模式的存储库
04-29
书中提到的所有设计模式的列表： 现实示例，类图，源代码，适用性，参考等解释的...策略设计模式 模板方法设计模式 委托模式 从我们的Github存储库下载源代码： https://github.com/RameshMF/gof-java-design-patterns
C语言实现设计模式—策略模式
Clear Code
11-12 2736
文章目录介绍抽象实现代码模块 介绍 在某些情况下，一个客户不想或者不能直接引用一个对象， 此时可以通过一个称之为“代理”的第三者来实现间接引用。 代理对象可以在客户端和目标对象之间起到中介的作用， 并且可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。 抽象 硬件代理模式使用结构体封装硬件设备，硬件有可能是内存、传感器设备、IO设备等，但无论什么样的设备，硬件代理的作用就是隐...
设计模式之一——策略模式及实现
奶牛
12-20 122
策略模式，又叫算法簇模式，就是定义了不同的算法族，并且之间可以互相替换，此模式让算法的变化独立于使用算法的客户。 策略模式的好处在于你可以动态的改变对象的行为。 设计原则是把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口（c++z中可以用虚类），然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。下面是一个例子。 /* 这是一...
设计模式之策略模式实践
Jacoh的专栏
04-02 985
设计模式
设计模式之策略模式(Java实现)
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
05-03 2691
文章目录前言一、认识策略模式二、实现策略模式2.1、 简单实现策略模式2.2、实际小案例实现策略模式总结参考资料 前言 本篇博客是关于策略模式的实现，若文章中出现相关问题，请指出！ 对应代码地址：Gitee（demo-exer/ java-Lear23designpatterns）、Github（java-demo/ java-Lear23designpatterns） 所有博客文件目录索引：博客目录索引(持续更新) 一、认识策略模式 策略模式定义：定义了算法族，将其封装起来，让它们直接可以互相替换，此模式
java设计模式之策略模式的优雅实现
zhaojun20161206的博客
12-28 6033
前言 策略模式是开发中常用的一种设计模式，主要解决在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护的问题。看了网上很多关于策略模式的上下文切换类实现都不甚优雅，故而想总结分享一篇自我感觉比较优雅的处理方式，方便大家一起学习。 方式一：使用@PostConstruct初始化到map中 该方式是比较常用的，相对比较优雅，能满足动态获取不同实现类的功能。废话不多说直接上代...
引入解释性变量
mypongo1
01-05 1302
在上一篇文章中介绍了“以查询取代临时变量“。本文将介绍“引入解释性变量”这种重构手法。下面让我们来学习这种重构手法吧。 开门见山发现：你有一个复杂的表达式。解决：将该复杂的表达式（或其中的部分）的结果放进一个临时变量，并以此变量名称来解释表达式用途。//重构前 if((platform.toUpperCase().indexOf(MAC) > -1)　&& (browser.toUpper
23种经典设计模式之策略模式
一个菜鸟的成长之路
11-03 4429
前言 相信只要是学过java或者其他面向对象编程语言的伙伴们多少都听说过设计模式，比如可以说算是烂大街的mvc、单例模式都是其中之一。当然设计模式的家族很庞大，远远不止这些。那设计模式是用来干什么的呢？和我们平时开发的程序又有什么关系呢？我们应当如何去使用它呢？我会介绍23种经典的设计模式以供理解和学习。 继承 现在我列举一种日常开放过程中经常碰到的一个例子。小明是一个程序员，负责公司oa系
极客大学架构师训练营 框架设计、设计原则、设计模式 第四课 听课总结
AI架构师易筋
06-18 1033
说明 框架设计 讲师：李智慧 对象对象编程与面向对象分析 面向对象编程不是使用面向对象的编程语言进行编程，而是利用多态特性进行编程。 面向对象分析是将客观世界，即编程的业务领域进行对象分析。 充血模型和贫血模型 领域驱动设计DDD 框架（Frameworks） 框架是用来实现某一类应用的结构性的程序，是对某一类架构方案可复用的设计与实现 如同框架架构的大厦的框架 简化应用开发者的工作 实现了多种设计模式，使应用开发者不需要花太大的力气，就能设计出结构良好的程序来 不同领域的框架 微软公司为Wind
软件设计应遵循的原则
jamesby
03-19 1993
[b]转自[/b] http://aladdin.iteye.com/blog/40809 http://blog.csdn.net/ponent2005/archive/2005/07/18/428305.aspx [b]一、单一职责原则(SRP)[/b] 就一个类而言,应该仅有一个引起它变化的原因,如果你能想到多于一个的动机去改变一个类,那么这个类就具有多于一个的指责.应该把多...
Java模式应用：SCAJ-001
"SCAJ-001 JAVA PATTERNS - 应用Java模式，由Stephen Stelting和Olav Maassen撰写，详细介绍了在J2EE和JINI技术环境中使用设计模式，涵盖Servlet、JSP、EJB和JavaSpaces API等核心技术。" 《SCAJ-001 JAVA PATTERNS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值