声明:本博客里面设计模式相关的文章,均是学习 《大话设计模式》 的笔记。
如果要做一个商场收银软件,输入商品的数量,单价,计算出收费总额,还要考虑商场的促销形式,比如打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();
}
}
输出截图:
简单工厂模式虽然解决了这个问题,但这个模式只是解决对象的创建问题,由于工厂本身包含了所有的收费方式,商场经常更改打折额度,返利额度,每次维护或者扩展收费方式都要改动这个工厂,会导致代码重新编译部署。面对这类算法的时常改动,应该有更好的解决模式,那就是策略模式。
策略模式(strategy),它定义了算法家族,分别封装起来,让他们之间可以互相替换,此模式让算法的替换不会影响到使用算法的客户。商场收银时如何促销,用打折还是返利,其实都是一些算法,用工厂来生成算法对象,这没有错,但算法本身只是一种策略,最重要的是这些算法是随时都可能互相替换的,这就是变化点,而封装变化点是我们面向对象的一种很重要的思维方式。策略模式结构图和基本代码:
//抽象算法类
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定义了一系列的可供重用的算法或行为,继承有助于析取出这些算法中的公共功能。这里的公共功能就是获得计算收费的结果。