设计模式(Java)----策略模式Strategy Pattern

最新推荐文章于 2024-08-22 15:48:21 发布

软耳.

最新推荐文章于 2024-08-22 15:48:21 发布

阅读量284

点赞数 1

文章标签： java 设计模式

本文链接：https://blog.csdn.net/jiahuier/article/details/106121848

版权

例题：做一个商场收银软件，营业员根据客户购买商品单价和数量，向客户收费。

import java.util.Scanner;

class Cash{
	public String list="";
	public Double totalPrice=0.00;
	public void buttonOK() {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价：");
		String price=sc.nextLine();
		System.out.println("输入数量");
		String num=sc.nextLine();
		Double xiaoji=Double.parseDouble(price)*Integer.parseInt(num);
		list+="单价："+price+",数量："+num+",小计："+xiaoji+"\n";
		totalPrice+=xiaoji;
	}
}
public  class Main{
	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.println("清单:\n"+cash.list);
	System.out.println("总价："+cash.totalPrice);
	}
}

Q:商场对商品搞活动，所有的商品打八折。
A:就在totalPrice后面乘以一个0.8
Q:商场活动结束，不打折了，还要再改一次程序代码，然后再用改过的程序去把所有机器全部安装一次。
Q:商场因为周午庆，打五折，怎么办?
A:加一个下拉选择框或输入折扣就可以解决以上问题。

import java.util.Scanner;

class Cash{
	public String list="";
	public Double totalPrice=0.00;
	public void buttonOK() {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价：");
		String price=sc.nextLine();
		System.out.println("输入数量");
		String num=sc.nextLine();
		System.out.println("输入折扣：");
		String zhekou=sc.nextLine();
		Double xiaoji=Double.parseDouble(price)*Integer.parseInt(num)*Double.parseDouble(zhekou)/10;
		list+="单价："+price+",数量："+num+",小计："+xiaoji+"\n";
		totalPrice+=xiaoji;
	}
}
public  class Main{
	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.println("清单:\n"+cash.list);
	System.out.println("总价："+cash.totalPrice);
	}
}

现在商场需求又来了，商场的活动加大，需要满300返100的促销算法。
可以用简单工厂模式:先写一个父类，再继承它实现多个打折和返利子类，利用多态，完成这个代码。由需求决定写几个子类，比如八折、七折、五折、满300送100.满200送50.....要几个写几个。

import java.util.Scanner;
//现金收取父类
abstract class CashSuper{
	//抽象方法：收取现金，参数为原价，返回为当前价
	public abstract double acceptCash(double money);
}
//正常收费类
class CashNormal extends CashSuper{

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money;
	}
	
}
//打折收费类
class CashRebate extends CashSuper{
	private double discount=0.00;
	public CashRebate(double discount) {
		this.discount=discount/10;
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return this.discount *money;
	}
	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;
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		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("1".equals(type)) cs=new CashNormal();
		else if("2".equals(type)) cs=new CashRebate(discount);
		else if("3".equals(type)) cs=new CashReturn(basePrice,returnPrice);
		return cs;
		
	}
}
public  class Main{
	public static void main(String[] args){
	boolean flag=true;
	String list="";
	Double totalPrice=0.00;
	while(flag) {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价");
		String price=sc.nextLine();
		System.out.println("输入数量");
		String num=sc.nextLine();
		System.out.println("输入折扣类型（1无折扣2打折3满减）：");
		String type=sc.nextLine();
	double discount=0.0d;
	double basePrice=0;
	double returnPrice=0;
	if("2".equals(type)) {
		System.out.println("输入折扣");
		discount=Double.parseDouble(sc.nextLine());
	}
	if("3".equals(type)) {
		System.out.println("返现基础金额");
		basePrice=Double.parseDouble(sc.nextLine());
		System.out.println("返现金额");
		returnPrice=Double.parseDouble(sc.nextLine());
	}
	Double xianjin=Double.parseDouble(price)*Integer.parseInt(num);
	CashSuper cs=CashAcceptFactory.createCashAccept(type, discount, basePrice, returnPrice);
	double xiaoji=cs.acceptCash(xianjin);
	list+="单价："+price+",数量："+num+",折扣："+discount+",返现基础金额"+basePrice+",返现金额"+returnPrice+",小计："+xiaoji+"\n";
	totalPrice+=xiaoji;
	if(totalPrice>10) {
		flag=false;
	}
	}
	System.out.println(list);
	System.out.println("总价："+totalPrice);
	}
}

简单工厂模式只是解决对象的创建问题，虽然工厂可能已经包括了所有的收费方式，但商场可能经常性地更改打折额度和返利额度，每次维护或扩展收费方式都需改动这个工厂以致代码需要重新编译部署，不符合开闭原则，所以不是最好的办法。

改进（策略模式）：

import java.util.Scanner;
//现金收取父类
abstract class CashSuper{
	//抽象方法：收取现金，参数为原价，返回为当前价
	public abstract double acceptCash(double money);
}
//正常收费类
class CashNormal extends CashSuper{

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money;
	}
	
}
//打折收费类
class CashRebate extends CashSuper{
	private double discount=0.00;
	public CashRebate(double discount) {
		this.discount=discount/10;
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return this.discount *money;
	}
	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;
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		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("1".equals(type)) cs=new CashNormal();
		else if("2".equals(type)) cs=new CashRebate(discount);
		else if("3".equals(type)) cs=new CashReturn(basePrice,returnPrice);
		return cs;
		
	}
}
//现金收取控制类
class CashContext{
	private CashSuper cs;
	public CashContext(CashSuper csuper) {//传入具体的收费策略对象（正常，打折或返利）
		this.cs=csuper;
	}
	public double GetResult(double money) {//根据不同收费策略，获得合计结果
		return cs.acceptCash(money);
	}
}
public  class Main{
	public static void main(String[] args){
	boolean flag=true;
	String list="";
	Double totalPrice=0.00;
	while(flag) {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价");
		String price=sc.nextLine();
		System.out.println("输入数量");
		String num=sc.nextLine();
		System.out.println("输入折扣类型（1无折扣2打折3满减）：");
		String type=sc.nextLine();
	double discount=0.0d;
	double basePrice=0;
	double returnPrice=0;
	CashSuper cs=null;
	if("1".equals(type)) cs=new CashNormal();
	else if("2".equals(type)) {
		System.out.println("输入折扣");
		discount=Double.parseDouble(sc.nextLine());
		cs=new CashRebate(discount);
	}
	else if("3".equals(type)) {
		System.out.println("返现基础金额");
		basePrice=Double.parseDouble(sc.nextLine());
		System.out.println("返现金额");
		returnPrice=Double.parseDouble(sc.nextLine());
		cs=new CashReturn(basePrice,returnPrice);
	}
	Double xianjin=Double.parseDouble(price)*Integer.parseInt(num);
	CashContext cc=new CashContext(cs);
	double xiaoji=cc.GetResult(xianjin);
	list+="单价："+price+",数量："+num+",折扣："+discount+",返现基础金额"+basePrice+",返现金额"+returnPrice+",小计："+xiaoji+"\n";
	totalPrice+=xiaoji;
	if(totalPrice>10) {
		flag=false;
	}
	}
	System.out.println(list);
	System.out.println("总价："+totalPrice);
	}
}

模式涉及到三个角色:
●环境(Context) 角色:持有一个Strategy类的引用(上下文对象)，负责和具体的策略类交互。
●抽象策略(Strategy)角色:这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策咯类所需的接口。
●具体策略(ConcreteStrategy) 角色:封装了具体的算法或行为。

//Strategy类，定义所有支持的算法的公共接口
abstract class Strategy{
	public abstract void algorithmInterface();
}
//ConcreteStrategy封装了具体的算法或行为，继承于Strategy
class ConcreteStrategyA extends Strategy{

	@Override
	public void algorithmInterface() {
		// TODO Auto-generated method stub
		System.out.println("算法A实现");
	}
}
class ConcreteStrategyB extends Strategy{

	@Override
	public void algorithmInterface() {
		// TODO Auto-generated method stub
		System.out.println("算法B实现");
	}
	
}
class ConcreteStrategyC extends Strategy{

	@Override
	public void algorithmInterface() {
		// TODO Auto-generated method stub
		System.out.println("算法C实现");
	}
	
}
class Context{
	Strategy strategy;
	public Context(Strategy strategy) {
		this.strategy=strategy;
	}
	public void contextInterface() {
		strategy.algorithmInterface();
	}
}
public  class Main{
	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();
	}
}

简单工厂模式:传条件进工厂类，工厂类就会返回一个对象给调用者，供调用者使用最终给用户使用的是工厂类返回的类。
策略模式:创建一个Context类(可以看作是工厂模式中工厂类的代替品)的对象context, 传一个要使用的策略实例对象A给context,然后使用context调用A中的某些方法–最终给用户用的是Context类。
简单的说:
工厂有进货也有出货，然后使用出货。
策略有进货没出货，然后使用得货者。
什么情况下应当使用策略模式？
1、当一个系统中有许多类，它们之间的区别仅在于它们的行为，希望动态地让一个对象在许多行为中选择一种行为时；
2、当一个系统需要动态地在几种算法中选择一种时；
3、当一个对象有很多的行为，不想使用多重的条件选择语句来选择使用哪个行为时。
策略模式的优点
1、策略类之间可以自由切换
由于策略类都实现同一价接中，所以使它们之间可以自由切换。
2、避免使用多重条件选播语句(if else) ,充分体现面向对象设计思想。
3、扩展性良好。
增加一个新的策略只需要添加一个具体的策略类，不改变原有的代码，符合“开闭原则”。

策略与简单工厂结合
针对策略模式的缺点:分支判断在客户端，改变算法时，要更改客户端的程序，意味着暴露了所有的具体策略类。
解决:其他都不变，改变类，把分支判断放到环境角色(CashContect类)中。

import java.util.Scanner;
//现金收取父类
abstract class CashSuper{
	//抽象方法：收取现金，参数为原价，返回为当前价
	public abstract double acceptCash(double money);
}
//正常收费类
class CashNormal extends CashSuper{

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money;
	}
	
}
//打折收费类
class CashRebate extends CashSuper{
	private double discount=0.00;
	public CashRebate(double discount) {
		this.discount=discount/10;
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return this.discount *money;
	}
	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;
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		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("1".equals(type)) cs=new CashNormal();
		else if("2".equals(type)) cs=new CashRebate(discount);
		else if("3".equals(type)) cs=new CashReturn(basePrice,returnPrice);
		return cs;
		
	}
}
//现金收取控制类
class CashContext{
	private CashSuper cs=null;
	public CashContext() {
				Scanner sc=new Scanner(System.in);
				System.out.println("输入折扣类型（1无折扣2打折3满减）：");
				String type=sc.nextLine();
			double discount=0.0d;
			double basePrice=0;
			double returnPrice=0;
			if("1".equals(type)) cs=new CashNormal();
			else if("2".equals(type)) {
				System.out.println("输入折扣");
				discount=Double.parseDouble(sc.nextLine());
				cs=new CashRebate(discount);
			}
			else if("3".equals(type)) {
				System.out.println("返现基础金额");
				basePrice=Double.parseDouble(sc.nextLine());
				System.out.println("返现金额");
				returnPrice=Double.parseDouble(sc.nextLine());
				cs=new CashReturn(basePrice,returnPrice);
			}
		}
	public double GetResult(double money) {//根据不同收费策略，获得合计结果
		return cs.acceptCash(money);
	}
}
public  class Main{
	public static void main(String[] args){
	boolean flag=true;
	String list="";
	Double totalPrice=0.00;
	while(flag) {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价");
		String price=sc.nextLine();
		System.out.println("输入数量");
		String num=sc.nextLine();
	Double xianjin=Double.parseDouble(price)*Integer.parseInt(num);
	CashContext cc=new CashContext();
	double xiaoji=cc.GetResult(xianjin);
	list+="单价："+price+",数量："+num+",小计："+xiaoji+"\n";
	totalPrice+=xiaoji;
	if(totalPrice>10) {
		flag=false;
	}
	}
	System.out.println(list);
	System.out.println("总价："+totalPrice);
	}
}

增加收费方法的对比
策略模式下，若增加收费方法，则

不需要更改:
①现金收费抽象类
②不变的具体的策略类
③CashContext类
需要更改/增加:
①新的具体的策略类
②客户端

策略模式和简单工厂结合的方法，若增加收费方法，则
不需要更改:
①现金收费抽象类
②不变的具体的策略类
③客户端
需要更改/增加:
①新的具体的策略类
②CashContext 类