设计模式-策略模式 java实现

浅浅的花香味﹌ 2022-07-26 00:21 185阅读 0赞

声明：本博客里面设计模式相关的文章，均是学习 《大话设计模式》 的笔记。

如果要做一个商场收银软件，输入商品的数量，单价，计算出收费总额，还要考虑商场的促销形式，比如打8折，满200减30等，先来看下使用简单工厂模式来实现这个需求的示例：

package strategy.pattern;  
//现金收费抽象类  
public abstract class CashSuper \{  
public abstract double acceptCash(double money);  
\}

//正常收费

public class CashNormal extends CashSuper \{  
@Override  
public double acceptCash(double money) \{  
return money;  
\}  
\}

//打折收费  
public class CashRebate extends CashSuper \{  
private double moneyRebate = 0.0d;  
public CashRebate(double rebate)\{  
moneyRebate = rebate;  
\}  
  
@Override  
public double acceptCash(double money) \{  
return money\*moneyRebate;  
\}  
\}

//返利收费

public class CashReturn extends CashSuper \{  
  
private double moneyCondition = 0.0d;  
private double moneyReturn = 0.0d;  
  
public CashReturn(double condition,double mReturn)\{  
moneyCondition = condition;  
moneyReturn =mReturn;  
\}  
  
  
@Override  
public double acceptCash(double money) \{  
double result=0.0d;  
if(money>moneyCondition)\{  
result = money - Math.floor(money/moneyCondition)\*moneyReturn;//Math.floor 取整数  
\}  
return result;  
\}  
\}

//简单工厂模式，现金收费工厂  
public class CashFactory \{  
public static CashSuper createCashAccept(int type)\{  
CashSuper mCs =null;  
  
switch (type)\{  
case 1://normal  
mCs = new CashNormal();  
break;  
case 2: //rebate  
mCs = new CashRebate(0.8);  
break;  
case 3://return  
mCs = new CashReturn(200,30);  
break;  
\}  
return mCs;  
\}  
\}

//客户端代码

import java.util.Scanner;  
public class CashSystem \{  
double total =0.0d;  
Scanner mScanner=null;  
CashSuper mCashSuper= null;  
  
public CashSystem() \{  
mScanner = new Scanner(System.in);  
System.out.println("input rebate type :1 normal cash ,2 rebate 8 ,3 return (200-30)");  
int type = mScanner.nextInt();  
mCashSuper = CashFactory.createCashAccept(type);  
\}  
  
void checkout()\{  
Scanner mScanner = new Scanner(System.in);  
  
System.out.println("please input item price:");  
double item\_price = mScanner.nextDouble();  
  
System.out.println("please input item numbers:");  
double item\_num = mScanner.nextDouble();  
  
double totalPrices = item\_price\* item\_num;  
total =total+totalPrices;  
double totalDis = mCashSuper.acceptCash(total);  
  
System.out.println("item price:"+item\_price+",item numbers:"+item\_num+", normal totalPrices:"+total+",rebate prices:"+totalDis);  
\}  
  
public static void main(String args\[\])\{  
CashSystem mCashSystem = new CashSystem();  
mCashSystem.checkout();  
\}  
\}

输出截图：![Center][]

简单工厂模式虽然解决了这个问题，但这个模式只是解决对象的创建问题，由于工厂本身包含了所有的收费方式，商场经常更改打折额度，返利额度，每次维护或者扩展收费方式都要改动这个工厂，会导致代码重新编译部署。面对这类算法的时常改动，应该有更好的解决模式，那就是策略模式。

策略模式（strategy），它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的替换不会影响到使用算法的客户。商场收银时如何促销，用打折还是返利，其实都是一些算法，用工厂来生成算法对象，这没有错，但算法本身只是一种策略，最重要的是这些算法是随时都可能互相替换的，这就是变化点，而封装变化点是我们面向对象的一种很重要的思维方式。策略模式结构图和基本代码：

![Center 1][]

//抽象算法类

abstract class Strategy\{

//算法方法

public abstract void AlgorithmInterface();

//具体算法类

class ConcreteStrategyA : Strategy\{

public override void AlgorithmInterface()\{

//算法A的具体实现

具体算法类ConcreteStrategyB，ConcreteStrategyC略

//上下文

class Context\{

Strategy mStrategy=null;

public Context(Strategy mStrategy)\{ //传入具体的策略对象

this.mStrategy = mStrategy;

//上下文接口

public void ContextInterface()\{ //根据具体的策略对象，调用其算法的方法

mStrategy.AlgorithmInterface();

//客户端代码

static void main(Strings\[\] args)\{

Context mContext =null;

mContext = new Context(new ConcreteStrategyA());//由于实例化了不同的策略，所以最终调用mContext.ContextInterface()时，所获得的结果就不会相同

mContext.ContextInterface();

mContext = new Context(new ConcreteStrategyB());

mContext.ContextInterface();

mContext = new Context(new ConcreteStrategyC());

mContext.ContextInterface();

下面是依据策略模式来实现的商场收费系统的代码，原来的CashNorma，CashRebate，CashReturn，CashSuper 都不用改，只用增加一个CashContext类：

public class CashContext \{  
private CashSuper mCashSuper = null;  
//这个构造函数的参数，可以是具体的策略类，但是要在客户端去判断具体是哪一种策略算法，这里是收费的类型，等于把原来放在客户端的判断拿到了这里。

//等于是策略与简单工厂模式的结合

public CashContext(int type)\{ //根据构造方法传入的收费类型，生成具体的收费策略  
switch (type)\{  
case 1://normal  
mCashSuper = new CashNormal();  
break;  
case 2: //rebate  
mCashSuper = new CashRebate(0.8);  
break;  
case 3://return  
mCashSuper = new CashReturn(200,30);  
break;  
\}  
\}  
  
public double getResult(double money)\{  
return mCashSuper.acceptCash(money);//根据收费策略的不同获得收费结果  
\}  
\}

//重写的客户端代码

import java.util.Scanner;  
public class CashClient \{  
double total =0.0d;  
Scanner mScanner=null;  
CashContext mCashContext = null;  
  
public CashClient() \{  
mScanner = new Scanner(System.in);  
System.out.println("input rebate type :1 normal cash ,2 rebate 8 ,3 return (200-30)");  
int type = mScanner.nextInt();  
mCashContext = new CashContext(type);  
\}  
  
void checkout()\{  
Scanner mScanner = new Scanner(System.in);  
  
System.out.println("please input item price:");  
double item\_price = mScanner.nextDouble();  
  
System.out.println("please input item numbers:");  
double item\_num = mScanner.nextDouble();  
  
double totalPrices = item\_price\* item\_num;  
total =total+totalPrices;  
double totalDis = mCashContext.getResult(total);  
  
System.out.println("item price:"+item\_price+",item numbers:"+item\_num+", normal totalPrices:"+total+",rebate prices:"+totalDis);  
\}  
  
public static void main(String args\[\])\{  
CashSystem mCashSystem = new CashSystem();  
mCashSystem.checkout();  
\}  
\}

比较上述2中收费系统的代码，简单工厂模式需要客户端认识两个类：CashSuper，CashFactory，而策略模式与简单工厂结合的用法，客户端只需要认识一个CashContext类就可以，耦合度降低了，而且使得具体的收费算法彻底地跟客户端分离。

策略模式是一种定义了一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类和使用算法类之间的耦合。

策略模式的strategy类层次为context定义了一系列的可供重用的算法或行为，继承有助于析取出这些算法中的公共功能。这里的公共功能就是获得计算收费的结果。

[Center]: /images/20220724/21d86f5f329945fe9699854fd4ed78c1.png
[Center 1]: /images/20220724/eb038ddb473b4c9aa44223cc9e2209cd.png