深入浅出学习设计模式之策略模式《一》

目录

深入浅出学习设计模式之策略模式《一》

深入浅出练习设计模式之装饰模式《二》

 

最近感觉自己上班上了很久的班，却感觉迷茫的很，思来想去，想想还是需要静下心来，回顾一下自己的知识，

今天就回顾一下自己刚开始学的设计模式，记录一下，设计模式 ，以便自己巩固复习

设计模式遵循的原则

1. 单一原则
2. 开闭原则
3. 历史代还
4. 依赖倒置
5. 接口隔离原则
6. 迪米特法则

1.策略模式

策略模式用一个简单的例子--商场促销

商场促销 经常会有活动，会员返积分，满300减100，无会员 正常收费，打8折等

如果硬编码的话，一般的思维方式是目前有什么需求就加什么条件，这只仅仅满足当下的业务，如果扩展的话，是非常困难的

而采用策略模式的话，就相对来说就用于扩展了

1.首先定义一个抽象类用于接受金额的参数

public abstract class CashSuper {
	//接受金额的收费抽象类
	public abstract double acceptCash(double money);
}

2.正常收费的子类

public class CashNomal extends CashSuper {

	//正常收费的子类
	@Override
	public double acceptCash(double money) {
		
		return money;
	}

}

3.打折的子类

public class CashRebate extends CashSuper {

	//定义一个打折比例默认不打折
	private double moneyRebate = 1d;
	//构造方法
	public CashRebate(String moneyRebate){
		this.moneyRebate = Double.parseDouble(moneyRebate);
	}
	@Override
	public double acceptCash(double money) {
		
		return money * moneyRebate;
	}

}

4.满xxx返xxx的子类

public class CashReturn extends CashSuper {

	//定义两个参数一个是满多少的参数
	//一个是返多少的参数
	private double moneyCondition = 0.0d;
	private double moneyReturn = 0.0d;
	/*
	 * 构造方法
	 */
	public CashReturn(String moneyCondition,String moneyReturn){
		this.moneyCondition = Double.parseDouble(moneyCondition);
		this.moneyReturn = Double.parseDouble(moneyReturn);
	}
	@Override
	public double acceptCash(double money) {
		double result = money;
		//若大于返利条件则需要减去返利值
		if(money >= moneyCondition){
			//保留两位小数
			double d = new BigDecimal(money/moneyCondition).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue();
			result = money - d * moneyReturn;
		}
		return result;
	}

}

5.定义一个上下文类用于对CashSuper的引用

public class CashContext {

	CashSuper cashSuper;
	
	public CashContext(CashSuper cashSuper) {
		this.cashSuper = cashSuper;
	}
	
	public void ContextInterface(double money){
		double acceptCash = cashSuper.acceptCash(money);
		System.out.println("返回的结果为"+acceptCash);
	}
}

6.测试结果为

public class Test {

	public static void main(String[] args) {
		double money = 500;
		/**
		 * 这里促销实例是根据选择的业务来定的
		 */
		CashContext cashContext;
		System.out.println("正常收费");
		cashContext = new CashContext(new CashNomal());
		cashContext.ContextInterface(money);
		
		System.out.println("满300返100");
		cashContext = new CashContext(new CashReturn("300", "100"));
		cashContext.ContextInterface(money);
		
		System.out.println("打8折");
		cashContext = new CashContext(new CashRebate("0.8"));
		cashContext.ContextInterface(money);
		
	}
}

这样就运用了一个简答的策略模式，

这里如果策略和简单工厂结合的话，就需要改造一下CashContext

改造后的CashContext

public class CashContext2 {

	CashSuper cs = null;
	
	public CashContext2(String type){
		switch (type) {
		case "正常收费":
			cs = new CashNomal();
			break;
		case "满300返100":
			cs = new CashReturn("300", "100");
			break;
		case "打8折":
			cs = new CashRebate("0.8");
			break;
		}
	}
	
	public double getResult(double money){
		
		return cs.acceptCash(money);
	}
}

测试结构

public class Test {

	public static void main(String[] args) {
		double money = 500;
		
		System.out.println("*************************改造后测试************************");
		CashContext2 cashContext2 =new CashContext2("正常收费");
		double result = cashContext2.getResult(500);
		System.out.println("正常收费："+result);
	}
}

需要不同的策略只需要传入不同的type，对于客户端来说，简化了

 

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

一句话概括：策略模式封装了变化

 

今天的总结就到这里，我是红哥，温故而知新，可以进步也，老鸟跳过，与新手共同进入，如需转载，请注明来源