大话设计模式之策略模式

铁铁匠

已于 2023-09-10 14:51:40 修改

阅读量46

点赞数

文章标签：设计模式策略模式 java

于 2020-05-10 11:28:28 首次发布

本文链接：https://blog.csdn.net/listening_nq/article/details/82621433

版权

参考内容

策略模式_「已注销」的博客-CSDN博客

策略模式_钟神发的博客-CSDN博客

设计模式学习之策略模式_进击的代码家的博客-CSDN博客

大话设计模式

什么是策略模式

设计一个商场收银软件，根据客户购买的数量和单价，收费，这是需求，看代码

public class Test1 {
/**
 * 需求：设计一个商场收银软件，根据客户购买的数量和单价，收费
 *      一。看看自己写的代码，问自己
 *      1.万一打8折，7折，6折，好多折怎么办，或者满多少返现多少等等，这个代码是不是太垃圾了，难道要改代码，或者重写吗，
 *      2。比如搞活动，打8折，你改了代码，total 乘以0.8，部署了代码，过了今天再该回来重新部署吗，显然不可能
 *      二。怎么办，想一想
 *      1。之前学了简单工厂模式，可以用简单工厂模式
 *      2.好，用简单工厂模式写需求
 *      3.看测试二代码 
 * 
 * */
	
	public void  charge(Double double1,Integer integer) {
		Double total=0D;
	  total=(double) (double1*integer);
		System.out.println(total);
	}
	public static void main(String[] args) {
		Test1 test1 = new Test1();
		test1.charge(1.2, 2);
	}
}

测试2代码

abstract class Cashsuper {
/**
 * 基类，正常价格是基类
 * */
	public abstract double getResult(double money);
	 
}

/**
 * 返现：需要两个参数，满多少，减多少，两个
 */
public class CashReturn extends Cashsuper {
	private double maxMoney;
	private double returnMoney;

	public double getMaxMoney() {
		return maxMoney;
	}

	public void setMaxMoney(double maxMoney) {
		this.maxMoney = maxMoney;
	}

	public double getReturnMoney() {
		return returnMoney;
	}

	public void setReturnMoney(double returnMoney) {
		this.returnMoney = returnMoney;
	}


	public CashReturn(double maxMoney, double returnMoney) {
		super();
		this.maxMoney = maxMoney;
		this.returnMoney = returnMoney;
	}

	@Override
	public double getResult(double money) {
		if (money>maxMoney) {
			double result=0d;
			result=money-Math.floor(money/maxMoney)*returnMoney;
			System.out.println(result);
			return result;
		}
		System.out.println(money);
		// TODO Auto-generated method stub
		return money;
		
	}

}

/**
 * 折扣类，折扣类有一个 打折的字段
 * */

public class CashRebate extends Cashsuper{

	public Double getMoneyRabate() {
		return moneyRabate;
	}
	public void setMoneyRabate(Double moneyRabate) {
		this.moneyRabate = moneyRabate;
	}
	private Double moneyRabate=1d;
	 public CashRebate(Double moneyRabate) {
		this.moneyRabate=moneyRabate;
	}
	@Override
	public double getResult(double money) {
		System.out.println(moneyRabate*money);
		// TODO Auto-generated method stub
		return moneyRabate*money;
	}

}

/**
 * 正常：是多少，要多少
 * */
public class CashNormal extends Cashsuper{

	@Override
	public double getResult(double money) {
		System.out.println(money);
		// TODO Auto-generated method stub
		return money;
	}

}

/**
 * 工厂模式：根据不同的条件创建不同的结算模式
 * */
public class CashFactory {

	public static Cashsuper createFactry(String value) {
		Cashsuper cashsuper=null;
		switch (value) {
		case "正常":
			cashsuper=new CashNormal();
			break;
		case "8折":
			cashsuper=new CashRebate(0.8d);
			break;
		case "300减100":
			cashsuper=new CashReturn(300, 100);
			break;
		default:
			System.out.println("没有符合的结算方式");
			break;
		}
		
		
		return cashsuper;}
}

public class Test2 {
	/**
	 * 简单工厂模式实现 收银代码 && 面向对象编程，不是类越多越好，类的划分是为了封装。但是分类的基础是抽象， 具有相同属性和功能的对象的抽象集合才是类 &&
	 * 不管打几折，只是形式不同，抽象分析出来，所有打折算法都是一样的，所以打折算法算一个类
	 * 一。写完代码,问自己
	 * 1.这样写确实好很多，不同的结算模式都有，但是，他解决了根本问题了吗，虽然
	 *   不同的结算模式都有，但是商城是多变的，为了营业额，会有乱七八糟的营销方式，
	 *   这个和计算器是不一样的，计算器就那几种工厂，商城不一样，可以巧立名目，今天想了一个营销的方式，改一下
	 *   代码？？明天又想一个，难道再改代码，重新部署，显然不科学
	 *   
	 * 2.到这里，简单工厂模式显然用的熟练了，但是，该怎么做呢，我们的需求还没真的完成
	 * 二。怎么办，想一想
	 * 1.我们已经把能结算的方式都写好了，只是算法不同，可能1，2，3，4，5折，1.1,1.2。。。等折扣，
	 * 还有各种满多少，减多少，不可能每次都在工厂里都分支一个case语句，然后去部署，不科学
	 * 2.所以用到，策略模式：
	 * 策略模式：她定义了算法家族，分别封装起来，它们之间可以相互替换，此模式让算法的变化，
	 * 不会影响到使用算法的用户。简单理解：封装算法，将变化的算法封装起来，以不变应万变
	 * 3.看测试3代码
	 * 
	 */
	public static void main(String[] args) {
		Cashsuper createFactry = null;
		// 打折
		createFactry = CashFactory.createFactry("8折");
		createFactry.getResult(300);
		// 折扣
		createFactry = CashFactory.createFactry("300减100");
		createFactry.getResult(301);
		// 原价
		createFactry = CashFactory.createFactry("正常");
		createFactry.getResult(300);
	}
}

ceshi 3

/**
 * 策略模式
 * */
public class CashContext {
Cashsuper cashsuper=null;
public CashContext(String type) {
	switch (type) {
	case "正常":
		cashsuper=new CashNormal();
		break;
	case "8折":
		cashsuper=new CashRebate(0.8d);
		break;
	case "300减100":
		cashsuper=new CashReturn(300, 100);
		break;
	default:
		System.out.println("没有符合的结算方式");
		break;
}
}
public double getResult(double money) {
	
	return cashsuper.getResult(money);}
}

/**
 * 策略模式：
 * 具有一个 context 类，是用来维护对一个 几类对象引用
 * 比较策略模式和简单工厂模式
 * ：简单工厂模式 需要客户端（Test类）认识工厂类和基类，但是策略模式只需要我们我们认识 context 类，这一个类，策略模式和工厂模式唯一不同的地方就在于  context 替换了 工厂类，context里包含了工厂类
 * 说实话：这个并没有实现（策略模式）之前说的，频繁地更新各种营销策略，仍需要我们去增加case 语句，如果要解决的话，需要用到
 * 反射技术。之后再看
 *  * */
public class Test3 {
 public static void main(String[] args) {
CashContext cashContext = new	CashContext("8折");
double result = cashContext.getResult(300);
System.out.println(result);
}
}