被说了很多遍的设计模式---策略模式

最新推荐文章于 2022-06-23 18:04:39 发布
最新推荐文章于 2022-06-23 18:04:39 发布
阅读量999 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 策略模式 教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abcd898989/article/details/52797020
版权

[把你的理性思维慢慢变成条件反射]

本文，我们讲介绍策略模式，文章主题结构与上位一致。惯例，先来看看我们示例工程的环境：

操作系统：win7 x64

其他软件：eclipse mars，jdk7

-------------------------------------------------------------------------------------------------------------------------------------

经典问题：

销售结算系统中的费用结算，在实际情况下，经常存在对于不同类型，级别的客户，或不同的商品，采用不同的折扣计价策略。

思路分析：

要点一：客户，存在不同类型。

要点二：商品，存在不同类型的折扣策略。

综合以上内容，系统中可能出现不同类型的调用方或者不同客户的参数。同时，运算方法存在多分支。

示例工程：


错误写法（1）：

创建CalculatorDebate.java，具体内容如下：

package com.csdn.ingo.gof_strategy.base;

import java.util.Scanner;


public class CalculatorDebate {

	public enum Debate {
		// 通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错
		// 赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
		_9("0.9"), _8("0.8"), _7("0.7"), _6("0.6"), _5("0.5");

		private final String value;

		// 构造器默认也只能是private, 从而保证构造函数只能在内部使用
		Debate(String value) {
			this.value = value;
		}

		public double getValue() {
			return Double.parseDouble(value);
		}
	}

	public static void main(String[] args) {
		double total = 0d;
		Scanner scan = new Scanner(System.in);
		
		while (true) {
			System.out.println("please enter number:");
			int numA = scan.nextInt();
			System.out.println("please enter prize:");
			int numB = scan.nextInt();
			System.out.println("please enter debate:");
			for(Debate debate : Debate.values()){
	            System.out.print(debate+",");
	        }
			String d = scan.next();
			Debate debate = Debate.valueOf("_"+d);
			total = (total + numA * numB);
			System.out.println("当前总价：" + total);
			System.out.println("折扣：" + debate.getValue());
			System.out.println("折后：" + total*debate.getValue());
		}
	}
}

错误原因：

虽然代码功能是正确的，并且能够满足不同的折扣策略。但是，请注意，这里的计算方法严格限制了只能结算一次，只能采用固定折扣计算方法，即9折，8折等类似的计算方法。而对于满减，根据客户级别的结算策略完全无法使用。并且，违反了我们第一篇文章介绍的“开闭原则”等诸多原则。故，这是一种极其不好的解决方案。

错误写法（2）：


创建CachFactory.java文件，具体内容如下：

package com.csdn.ingo.gof_strategy.one;

public class CachFactory {
	public static CashSuper createCashFactory(String type){
		CashSuper cs = null;
		switch(type){
		case "1":
			cs = new CashNormal();
			break;
		case "mj":
			cs = new CashReturn("300", "100");
			break;
		case "2":
			cs = new CashRebate("0.8");
			break;
		}
		return cs;
	}
}
创建CashNormal.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.one;

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

}
创建CashRebate.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.one;

public class CashRebate extends CashSuper {
	public double moneyRebate = 1d;
	public CashRebate(String moneyRebate){
		this.moneyRebate = Double.parseDouble(moneyRebate);
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money*moneyRebate;
	}

}
创建CashReturn.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.one;

public class CashReturn extends CashSuper{
	private double moneyCondition = 0d;
	private double moneyReturn =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){
			result = money-Math.floor(money/moneyCondition)*moneyReturn;
		}
		return result;
	}

}
创建CashSuper.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.one;

public abstract class CashSuper {
	public abstract double acceptCash(double money);
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.one;

import java.util.Scanner;

public class Window {
	public static void main(String[] args) {
		double total = 0d;
		String isEnd = "y";
		Scanner scan = new Scanner(System.in);
		while(isEnd.equals("y")){
			System.out.println("please enter number:");
			int numA = scan.nextInt();
			System.out.println("please enter prize:");
			int numB = scan.nextInt();
			total = (total+numA*numB);
			System.out.println("当前总价："+total);
			System.out.println("继续添加（y/n）：");
			isEnd = scan.next();
		}
		CashSuper csuper = CachFactory.createCashFactory("2");
		total= csuper.acceptCash(total);
		System.out.println("折扣："+"2");
		System.out.println("折后总价："+total);
	}
}

错误原因：

version_one的代码，虽然在功能上实现了无限制的商品计价，并且在代码设计上讲不通的策略进行隔离，满足了“单一职责原则”，“开闭原则”等。并且使用前文的简单工厂模式加以实现。但是，我们需要注意谨慎简单工厂模式的使用。因为，该模式只是负责创建了不同类型的对象而已。细心的读者应该记得，我们前文介绍过简单工厂模式的限制条件：通过静态方法创建实例对象。换句话说，对于经常改变营销策略的销售系统，每次都需要重新开发，编译软件的代价是巨大的。所以，该方案的错误原因是不符合实际需求。

错误写法（2）：


创建CashContext.java文件，具体内容如下：

package com.csdn.ingo.gof_strategy.three;


public class CashContext {
	private CashSuperStrategy cashSuperStrategy;

	public CashContext(CashSuperStrategy cashSuperStrategy) {
		this.cashSuperStrategy = cashSuperStrategy;
	}

	public double getResult(double money) {
		return cashSuperStrategy.acceptCash(money);
	}
}
创建CashNormal.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.three;

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

}
创建CashRebate.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.three;

public class CashRebate extends CashSuperStrategy {
	public double moneyRebate = 1d;
	public CashRebate(String moneyRebate){
		this.moneyRebate = Double.parseDouble(moneyRebate);
	}
	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money*moneyRebate;
	}

}
创建CashReturn.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.three;

public class CashReturn extends CashSuperStrategy{
	private double moneyCondition = 0d;
	private double moneyReturn =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){
			result = money-Math.floor(money/moneyCondition)*moneyReturn;
		}
		return result;
	}

}

创建CashSuperStrategy.java文件，具体内容如下：

package com.csdn.ingo.gof_strategy.three;

public abstract class CashSuperStrategy {
	public abstract double acceptCash(double money);
}
创建Window.java文件，具体内容如下： 
package com.csdn.ingo.gof_strategy.three;

import java.util.Scanner;

public class WIndow {
	public static void main(String[] args) {
		double total = 0d;
		String isEnd = "y";
		Scanner scan = new Scanner(System.in);
		while(isEnd.equals("y")){
			System.out.println("please enter number:");
			int numA = scan.nextInt();
			System.out.println("please enter prize:");
			int numB = scan.nextInt();
			total = (total+numA*numB);
			System.out.println("当前总价："+total);
			System.out.println("继续添加（y/n）：");
			isEnd = scan.next();
		}
		CashContext cs = null;
		String type = "fl";
		switch(type){
		case "1":
			cs = new CashContext(new CashNormal());
			break;
		case "fl":
			cs = new CashContext(new CashReturn("300", "100"));
			break;
		case "2":
			cs = new CashContext(new CashRebate("0.8"));
			break;
		}
		total= cs.getResult(total);
		System.out.println("折扣："+"1");
		System.out.println("折后总价："+total);
	}
}

错误原因：

version_three的已经实现了我们将要介绍策略模式的主体设计。但是，在Window.java文件中，出现了一个违反“单一职责原则”的写法，及策略的判断留给了客户端。在实际开发中，客户端是丝毫不需要关注这部分操作的，于是，我们需要将这部分内容转移到其他地方。

推荐写法：


修改CashContext.java文件，具体内容如下：

package com.csdn.ingo.gof_strategy.four;

import com.csdn.ingo.gof_strategy.three.CashNormal;
import com.csdn.ingo.gof_strategy.three.CashRebate;
import com.csdn.ingo.gof_strategy.three.CashReturn;
import com.csdn.ingo.gof_strategy.three.CashSuperStrategy;


public class CashContext {
	private CashSuperStrategy cashSuperStrategy;

	public CashContext(String type) {
		switch(type){
		case "1":
			cashSuperStrategy = new CashNormal();
			break;
		case "fl":
			cashSuperStrategy = new CashReturn("300", "100");
			break;
		case "2":
			cashSuperStrategy = new CashRebate("0.8");
			break;
		}
	}

	public double getResult(double money) {
		return cashSuperStrategy.acceptCash(money);
	}
}
修改Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_strategy.four;

import java.util.Scanner;

public class Window {
	public static void main(String[] args) {
		double total = 0d;
		String isEnd = "y";
		Scanner scan = new Scanner(System.in);
		while(isEnd.equals("y")){
			System.out.println("please enter number:");
			int numA = scan.nextInt();
			System.out.println("please enter prize:");
			int numB = scan.nextInt();
			total = (total+numA*numB);
			System.out.println("当前总价："+total);
			System.out.println("继续添加（y/n）：");
			isEnd = scan.next();
		}
		CashContext cs = new CashContext("2");
		total= cs.getResult(total);
		System.out.println("折后总价："+total);
	}
}

推荐原因：

  • 符合“单一职责原则”，“开闭原则”等
  • 客户端，每个计算单元均是独立的，达到易扩展，易维护的目的。
  • 使用方调用不同策略的方式完全相同，减少了调用方与提供方之间的耦合度。并且提高了算法的重用次数。
  • 提供了单元测试能力，因为，每一个策略都有独立的实现过程。
  • Context类将条件语句封装为类的行为，将各种类型规则封装为统一的外在表现。有效减少了其他组件的功能及负担。特别的：对于条件语句的更高级的实现方式将在后文介绍（配置文件中设置具体子类名，反射机制），这里我们先将其独立为类行为，方便后续操作。敬请期待！


模式总结：

UML结构图：

概念总结：

策略模式：该模式定义了一系列算法的集合，分别封装为独立的单元，使得他们之间可以相互替换，并且使得算法的变化，不会影响到使用该算法的客户。

组成部分：Context，抽象父类，具体子类，三部分组成。

用法总结：

根据结构图，创建3个基本组成部分。客户端只需要传入算法必须的参数，Context负责决定具体策略，每个具体的实现类均独立。特别注意：客户端的代码中不要加入条件判断等多余代码，防止后期维护时产生不可预知的错误。另外，作为模式的讲解，我们暂时不介绍如何通过配置文件的方式实现动态策略调整，更多内容请各位看官自行学习。

反思：

应用场景：

  1. 系统中存在需要根据某些条件动态的选择一个算法实现，而这些算法具有某个相同的共性。换句话说，能够抽象出一个父类。
  2. 系统中某个对象的行为不确定，无法满足“单一职责原则”时。
  3. 希望对客户端屏蔽算法的实现细节，以提高安全性。

优点：

  1. 完全符合“开闭原则”。能够实现在不修改原有系统的同时，灵活的增加新的算法及实现类。
  2. 将众多的具体实现抽象为一个父类，一定程度上的减少了重复的公共代码。
  3. Context类将策略的选择功能完全的独立出来，同事避免了多重选择语句，方便的实现了后续的调整。
  4. 极大的简化了客户端的代码量，方便了客户端的使用。

缺点：

  1. 当具体的策略类非常多时，客户端虽然不需要显示的判断，但仍需要非常清楚不同策略之间的区别。
  2. 造成系统内过多的策略算法文件。
  3. 无法组合策略。客户端只能选择调用某一个具体的策略执行。

特别注意：

上文中，我们给出的示例代码是通过多重选择的形式来执行具体的实现类。在实际使用时，客户端也可以直接通过指明实现类的方式来调用具体的实现类（里氏代换原则）。

-------------------------------------------------------------------------------------------------------------------------------------

至此，被说了很多遍的设计模式---策略模式 结束


参考资料：

图书：《大话设计模式》

其他博文：http://blog.csdn.NET/lovelion/article/details/7563445

y-yg
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式-策略模式
12-21
所谓策略模式，即 定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。 通俗的一点来讲，当同一个操作，可能有...我们在电商平台购物，到支付支付的时候，通常会有很多的支付方式可以选择，比如说有：支
Java设计模式之策略模式(UML类图分析+代码详解)
m0_51750419的博客
10-26 4820
策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体 设定行为对象。1) 策略模式（Strategy Pattern）中，定义算法族，分别封装起来，让他们之间可以 互相替换，此模式让算法的变化独立于使用算法的客户。2) 上面说的1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改 动，会影响其他部分。1) 其它鸭子，都继承了Duck类，所以fly让所有子类都会飞了，这是不正确的。1) 应用实例要求 编写程序完成前面的鸭子项目，要求使用策略模式。
23种设计模式
heshihu2019的博客
06-23 279
1、简单工厂模式（创建型模式，用于资源的统一分发 如加减乘除功能类，需要引用，增加代码复杂度，实现低耦合代码复用） 2、策略模式 （行为型模式，用于同一时间条件不同业务） 1与2区别 https://blog.csdn.net/xjh1997/article/details/81078716/ 3、装饰模式（新建类装饰另类功能，简化原有类） 4、代理模式（为其他对象代理访问这个对象） 5、工厂方法模式（与1相似，客户端用哪些功能，1把判断放在工厂类内，5把判断交给客户端）https://www.bookst
设计模式学习之策略模式
热门推荐
一个码农的博客
04-11 7万+
写代码时总会出很多的if…else，或者case。如果在一个条件语句中又包含了多个条件语句就会使得代码变得臃肿，维护的成本也会加大，而策略模式就能较好的解决这个问题，本篇博客就带你详细了解策略模式。策略模式的定义和使用场景定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。分析下定义，策略模式定义和封装了一系列的算法，它们是可以相互替
设计模式：UML类图、策略模式、单例模式、工厂模式、观察者模式
ehuangdan5864的博客
08-01 2349
一、UML类图： 类与类之间存在6个关系： 1）依赖：类A用到了类B，不是成员变量中用到，而是在成员函数中用到了 2）关联：类A使用了类B，并且是在成员变量中用到的 3）聚合：和关联类似，也是使用实例化来关联，一个是整体，一个是部分 4）组合：相比聚合具有更强的耦合度。部分没有单独存在的意义，整体负责单独的生命周期。 5）继承： 6）实现：纯虚函数 二、策略模式： strategy中的算法经常变化。所以将strategy中的算法作为虚函数，在派生类中进行重写。Context中包含了一个stra
多个if-else出现选用哪些设计模式
07-25 3535
待继续添加
10.设计模式-策略模式1
08-03
1.当你有很多类似的类，但它们执行某些行为的方式不同时，请使用此 2.使用该模式将类的业务逻辑与算法的实现细节隔离开来，这些算法在 3.当你的类具有大量的条件运
鸭子-策略模式
02-27
前言万事开头难，最近对这句话体会深刻！...上一篇：模式和原则，得到很多朋友的支持和鼓励，这里再次深表感谢。这里我还是想呼吁一下，希望大家看过后多提宝贵意见，反对意见更好，关键是我们在互动中可以
我的实践与反思-策略模式
02-27
刚开始的时候懵懵懂懂，后来若有所思，最令我感觉深刻的是曾经认为不对的现在觉得未必不对，曾经被抛弃的做法现在可能又重新捡起，也许这就是很多高人所说的螺旋上升的过程，也是公司和部门去年一直宣讲的“实践-...
来吧，用设计模式来干掉 if-else 啊~
芋艿V
10-20 365
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 8:55 更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2020 超神之路，很肝~...
设计模式 ( 十八 ) 策略模式Strategy（对象行为型）
管子（zero）的杂乱空间
05-12 2103
设计模式 ( 十八 ) 策略模式Strategy（对象行为型） 1.概述 在软件开发中也常常遇到类似的情况，实现某一个功能有多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。如查找、排序等，一种常用的方法是硬编码(Hard Coding)在一个类中，如需要提供多种查找算法，可以将这些算法写到一个类中，在该类中提供多个方法，每一个方法对应一个具体的查...
设计模式总结一（UML类图、简单工厂模式、策略模式和单一职责原则）
My Struggle
01-04 912
前言 我写这篇博文，是对我研一这一学期到现在，学习设计模式的总结。我自己使用的是程杰写的《大话设计模式》这本书，我会跟据这本书，对自己这么多天学习到的知识做一个总结。 目前，第一篇先总结前三章。涉及到的只是有：第一章讲述的UML类图和简单工厂模式，第二章的策略模式和第三章的单一职责原则。首先，先来看第一章地1.11节的UML类图。 UML类图 类图 类图分为三层，第一层是类名；第二层是类特性，即类成员；第三层则是列操作，即类的成员函数。其中，+表示public，-表示private...
用设计模式来代替臃肿的ifelse层层判断
ghevinn欢迎您光临
04-30 4万+
----------------------------------------------------------------- 在www.infoq.com/cn网站上看了一本书叫《ThoughtWorks文集》，里边有一章讲的是“对象健身操”，其中提到了“拒绝使用else关键字”。那么如何“拒绝使用else关键字”呢？               1、如果程序中只有一个else
二十三种设计模板之策略模式
fbher的博客
04-20 105
概念： 在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。 理解： 其实策略模式在java中来说，就是编译时多态，什么是运行时多态呢，就是...
设计模式学习
zhs4430169的专栏
08-24 337
设计模式学习笔记 设计模式（Design pattern）的使用是为了重用代码、让代码更容易被他人理解、保证代码可靠性。个人理解：设计模式的使用更多的是为了解耦，代码的可扩展性以及稳定性，可阅读性并不一定得到了提高（相反过多的封装会是可阅读性变得更差）。 这个笔记的更多理解来自与设计模式简介以及个人的补充，只是学习的一个记录和整理，方便以后进行系统设计时候的查阅理解。这里的理解与举例更多的...
策略模式UML图形及代码
bug_yun的博客
07-06 2554
参考：http://blog.csdn.net/lovelion/article/details/17517213    //电影票类：环境类 class MovieTicket { private double price; private Discount discount; //维持一个对抽象折扣类的引用 public voi...
策略模式实例与UML
拼搏的小船长
11-29 981
<?php interface FlyBehavior{ public function fly(); } class FlyWithWings implements FlyBehavior{ public function fly(){ echo "Fly With Wings ".PHP_EOL; } } class FlyWithNo implem
设计模式--策略模式--UML图
hailushijie的专栏
11-25 3865
策略模式： http://blog.csdn.net/droyon/article/details/8611418
基于SpringBoot和注解实现策略模式解决重复使用(if--else)的问题
ls490447406的博客
12-17 1382
应用场景： 实际开发： 最近在项目中遇到一个开发场景，需要根据type值判断来执行对应的业务逻辑，这样就涉及到重复的if-else的问题，为了解决这样重复的代码来造成的代码冗余的问题，所以考虑使用策略模式，根据具体的场景执行对应的策略，来解决问题。本文简单写一个测试Demo，实际开发需要根据具体业务，具体实现对应的业务逻辑。 总结： 因为业务需求需要重复的判断，造成代码冗余。 具体方案（...
用设计模式代替if-else
最新发布
05-27
当代码中的条件语句if-else过于复杂时，可以考虑使用设计模式代替if-else语句，提高代码的可读性和可维护性。以下是一些常见的设计模式，可以用来代替if-else语句： 1. 工厂模式（Factory Pattern）：通过工厂方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值