设计模式 —— 策略模式

最新推荐文章于 2024-06-22 17:20:50 发布
最新推荐文章于 2024-06-22 17:20:50 发布
阅读量172 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yu_Nan___/article/details/106080386
版权

策略模式

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

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。这本身并没有解除客户端需要选择判断的压力，可以将策略模式和简单工厂模式结合，选择具体来实现的职责就可以给Context来承担，最大化地减轻了客户端的职责。
在这里插入图片描述实例：商场收银v1.0
代码：

package org.zangyu.Stragety;

import java.util.Scanner;

public class Stragety {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Cash cash=new Cash();
      boolean flag =true;
      while(flag) {
    	  cash.buttonOK();
    	  System.out.println("------------------------------");
          System.out.println("清单：\n"+cash.list);
          System.out.println("总价："+cash.toalprice);
    	  if(cash.toalprice>10) {
    		  flag=false;
    	  }
      }
	}

}
class Cash{
	public String list="";
	public double toalprice=0.00;
	public void buttonOK() {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价:");
		String price =sc.nextLine();
		System.out.println("输入数量:");
		String num =sc.nextLine();
		double xiaoji =Double.parseDouble(price)*Integer.parseInt(num);
		list+="单价:"+price+",数量:"+num+",小计:"+xiaoji+"\n";
		toalprice+=xiaoji;
	}
}

商场收银（享有折扣）V1.1
代码：

package org.zangyu.Stragety;

import java.util.Scanner;

public class Stragety {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Cash cash=new Cash();
      boolean flag =true;
      while(flag) {
    	  cash.buttonOK();
    	  System.out.println("------------------------------");
          System.out.println("清单：\n"+cash.list);
          System.out.println("总价："+cash.toalprice);
    	  if(cash.toalprice>10) {
    		  flag=false;
    	  }
      }
	}

}
class Cash{
	public String list="";
	public double toalprice=0.00;
	public void buttonOK() {
		Scanner sc=new Scanner(System.in);
		System.out.println("输入单价:");
		String price =sc.nextLine();
		System.out.println("输入数量:");
		String num =sc.nextLine();
		System.out.println("输入折扣:");
		String discount=sc.nextLine();
		double xiaoji =Double.parseDouble(price)*Integer.parseInt(num)*Double.parseDouble(discount)/10;;
		list+="单价:"+price+",数量:"+num+",小计:"+xiaoji+"\n";
		toalprice+=xiaoji;
	}
}

商场收银（满减）V1.2
代码：简单工厂模式
在这里插入图片描述

package org.zangyu.Stragety;

import java.util.Scanner;

public class Stragety1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		boolean flag = true;
		String list = "";
		double toalprice = 0.00;
		while (flag) {
			Scanner sc = new Scanner(System.in);
			System.out.println("输入单价:");
			String price = sc.nextLine();
			System.out.println("输入数量:");
			String num = sc.nextLine();
			System.out.println("输入折扣类型（1、无折扣 2、打折 3、满减）");
			int type = sc.nextInt();
			double discount = 10;
			double baseprice = 0;
			double returnprice = 0;
			if (type == 2) {
				sc = new Scanner(System.in);
				System.out.println("输入折扣");
				discount = Double.parseDouble(sc.nextLine());
			}
			else if (type == 3) {
				sc = new Scanner(System.in);
				System.out.println("返现基础金额");
				baseprice = Double.parseDouble(sc.nextLine());
				System.out.println("返现金额");
				returnprice = Double.parseDouble(sc.nextLine());
			}
			double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
			CashSuper cs = CashAcceptFactory.createCashAccept(type, discount, baseprice, returnprice);
			double xiaoji = cs.acceptCash(xianjin);
			toalprice+=xiaoji;
			list = "单价：" + price + "，数量：" + num + ",折扣：" + discount + ",小计：" + xiaoji + "\n";
			System.out.println("------------------------------");
			System.out.println("清单：\n" + list);
			System.out.println("总价：" + toalprice);
			if (toalprice > 10) {
				flag = false;
			}
		}
	}

}

//现金收取工厂
class CashAcceptFactory {
	// 根据条件生成相应的对象
	public static CashSuper createCashAccept(int type, double discount, double baseprice, double returnprice) {
		CashSuper cs = null;
		switch (type) {
		case 1:
			cs = new CashNormal();
			break;
		case 2:
			cs = new CashRebate(discount);
			break;
		case 3:
			cs = new CashReturn(baseprice, returnprice);
			break;
		}
		return cs;
	}
}

//现金收取父类
abstract class CashSuper {
	// 抽象方法：收取现金，参数为原价，返回为当前价
	public abstract double acceptCash(double money);
}

//正常收费类
class CashNormal extends CashSuper {

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money;
	}

}

//打折收费类，继承CashSuper
class CashRebate extends CashSuper {
	private double discount = 0.00;

	// 初始化时，必需要输入折扣率
	public CashRebate(double discount) {
		this.discount = discount / 10;
	}

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return this.discount * money;
	}

	public double getDiscount() {
		return this.discount;
	}

	public void setDiscount(double discount) {
		this.discount = discount / 10;

	}
}

//返利收费，继承CashSuper
class CashReturn extends CashSuper {
	private double basecash;// 基础金额
	private double returncash;// 返现金额
	// 初始化时必须要输入返利条件和返利值

	public CashReturn(double basecash, double returncash) {
		this.basecash = basecash;
		this.returncash = returncash;
	}

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		double result = money;
		if (money >= basecash)// 若大于返利条件，则需要减去返利值
		{
			result = money - Math.floor(money / basecash) * returncash;
		}
		return result;
	}

	public double getBasecash() {
		return basecash;
	}

	public void setBasecash(double basecash) {
		this.basecash = basecash;
	}

	public double getReturncash() {
		return returncash;
	}

	public void setReturncash(double returncash) {
		this.returncash = returncash;
	}

}

商场收银（满减）V1.3
改造现金工厂——代码：

package org.zangyu.Stragety;

import java.util.Scanner;

public class Stragety2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		boolean flag = true;
		String list = "";
		double toalprice = 0.00;
		while (flag) {
			Scanner sc = new Scanner(System.in);
			System.out.println("输入单价:");
			String price = sc.nextLine();
			System.out.println("输入数量:");
			String num = sc.nextLine();
			System.out.println("输入折扣类型（1、无折扣 2、打折 3、满减）");
			int type = sc.nextInt();
			double discount = 10;
			double baseprice = 0;
			double returnprice = 0;
			CashSuper cs=null;
			if(type==1) {cs=new CashNormal();}
			else if(type == 2) {
				sc = new Scanner(System.in);
				System.out.println("输入折扣");
				discount = Double.parseDouble(sc.nextLine());
			    cs=new CashRebate(discount);
			     
			}
			else if (type == 3) {
				sc = new Scanner(System.in);
				System.out.println("返现基础金额");
				baseprice = Double.parseDouble(sc.nextLine());
				System.out.println("返现金额");
				returnprice = Double.parseDouble(sc.nextLine());
			    cs=new CashReturn(baseprice, returnprice);
			}
			double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
			CashContext cc=new CashContext(cs);
			double xiaoji = cc.GetResult(xianjin);
			toalprice+=xiaoji;
			list = "单价：" + price + "，数量：" + num + ",折扣：" + discount + ",小计：" + xiaoji + "\n";
			System.out.println("------------------------------");
			System.out.println("清单：\n" + list);
			System.out.println("总价：" + toalprice);
			if (toalprice > 10) {
				flag = false;
			}
		}
	}

}
//现金收取控制类
class CashContext{
	private CashSuper cs;//声明一个现金收取父类对象
	public CashContext(CashSuper cs)
	{
		//通过够着方法，传入具体的收费对策
		this.cs=cs;
	}
	public double GetResult(double money) {
		//返回结果
		return cs.acceptCash(money);
	}
}
//现金收取父类
abstract class CashSuper {
	// 抽象方法：收取现金，参数为原价，返回为当前价
	public abstract double acceptCash(double money);
}

//正常收费类
class CashNormal extends CashSuper {

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money;
	}

}

//打折收费类，继承CashSuper
class CashRebate extends CashSuper {
	private double discount = 0.00;

	// 初始化时，必需要输入折扣率
	public CashRebate(double discount) {
		this.discount = discount / 10;
	}

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return this.discount * money;
	}

	public double getDiscount() {
		return this.discount;
	}

	public void setDiscount(double discount) {
		this.discount = discount / 10;

	}
}

//返利收费，继承CashSuper
class CashReturn extends CashSuper {
	private double basecash;// 基础金额
	private double returncash;// 返现金额
	// 初始化时必须要输入返利条件和返利值

	public CashReturn(double basecash, double returncash) {
		this.basecash = basecash;
		this.returncash = returncash;
	}

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		double result = money;
		if (money >= basecash)// 若大于返利条件，则需要减去返利值
		{
			result = money - Math.floor(money / basecash) * returncash;
		}
		return result;
	}

	public double getBasecash() {
		return basecash;
	}

	public void setBasecash(double basecash) {
		this.basecash = basecash;
	}

	public double getReturncash() {
		return returncash;
	}

	public void setReturncash(double returncash) {
		this.returncash = returncash;
	}

}

策略模式基本框架：

package org.zangyu.Stragety;

public class Strategy3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Context con;
		con=new Context(new CStrategy1());
		con.contextInterface();
		con=new Context(new CStrategy2());
		con.contextInterface();
		con=new Context(new CStrategy3());
		con.contextInterface();
	}

}
//定义所有支持算法的公共接口
abstract class Strategy{
	public abstract void algorithInterace();
}
//CStrategy 封装了具体的算法或行为，继承于Strategy
class CStrategy1 extends Strategy
{

	@Override
	public void algorithInterace() {
		// TODO Auto-generated method stub
		System.out.println("算法一实现");
	}
	
}
class CStrategy2 extends Strategy
{

	@Override
	public void algorithInterace() {
		// TODO Auto-generated method stub
		System.out.println("算法二实现");
	}
	
}
class CStrategy3 extends Strategy
{

	@Override
	public void algorithInterace() {
		// TODO Auto-generated method stub
		System.out.println("算法三实现");
	}
	
}
//Context 维护对一个Strategy对象的引用
class Context
{
	Strategy sta;
	public Context(Strategy sta) {
		//初始化时，传入具体的策略对像
		this.sta=sta;
	}
	public void contextInterface()
	{
		sta.algorithInterace();
		//根据具体策略对象，调用其方法
	}
}

商场收银（满减）V1.4
简单工厂与策略模式结合：

package org.zangyu.Stragety;

import java.util.Scanner;

public class Stragety3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		boolean flag = true;
		String list = "";
		double toalprice = 0.00;
		while (flag) {
			System.out.println("输入单价:");
			String price = sc.nextLine();
			System.out.println("输入数量:");
			String num = sc.nextLine();
			double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
			CashContext cc=new CashContext();
			double xiaoji = cc.GetResult(xianjin);
			toalprice+=xiaoji;
			list = "单价：" + price + "，数量：" + num + ",折扣：" +cc.discount + ",小计：" + xiaoji + "\n";
			System.out.println("------------------------------");
			System.out.println("清单：\n" + list);
			System.out.println("总价：" + toalprice);
			if (toalprice > 10) {
				flag = false;
			}
		}
	}

}
//现金收取控制类
class CashContext{
	Scanner sc = new Scanner(System.in);
	double discount = 10;
	double baseprice = 0;
	double returnprice = 0;
	private CashSuper cs=null;//声明一个现金收取父类对象
	public CashContext() {
    System.out.println("输入折扣类型（1、无折扣 2、打折 3、满减）");
	int type = sc.nextInt();
	if(type==1) {
		cs=new CashNormal();
		}
	else if(type==2) {  
		sc = new Scanner(System.in);
		System.out.println("输入折扣");
		discount = Double.parseDouble(sc.nextLine());
	    cs=new CashRebate(discount);
	     
	}
	else if (type == 3) {
		sc = new Scanner(System.in);
		System.out.println("返现基础金额");
		baseprice = Double.parseDouble(sc.nextLine());
		System.out.println("返现金额");
		returnprice = Double.parseDouble(sc.nextLine());
	    cs=new CashReturn(baseprice, returnprice);
	}
  }
  public double GetResult(double money) {
	  return cs.acceptCash(money);
  }
}
//现金收取父类
abstract class CashSuper {
	// 抽象方法：收取现金，参数为原价，返回为当前价
	public abstract double acceptCash(double money);
}

//正常收费类
class CashNormal extends CashSuper {

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return money;
	}

}

//打折收费类，继承CashSuper
class CashRebate extends CashSuper {
	private double discount = 0.00;

	// 初始化时，必需要输入折扣率
	public CashRebate(double discount) {
		this.discount = discount / 10;
	}

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		return this.discount * money;
	}

	public double getDiscount() {
		return this.discount;
	}

	public void setDiscount(double discount) {
		this.discount = discount / 10;

	}
}

//返利收费，继承CashSuper
class CashReturn extends CashSuper {
	private double basecash;// 基础金额
	private double returncash;// 返现金额
	// 初始化时必须要输入返利条件和返利值

	public CashReturn(double basecash, double returncash) {
		this.basecash = basecash;
		this.returncash = returncash;
	}

	@Override
	public double acceptCash(double money) {
		// TODO Auto-generated method stub
		double result = money;
		if (money >= basecash)// 若大于返利条件，则需要减去返利值
		{
			result = money - Math.floor(money / basecash) * returncash;
		}
		return result;
	}

	public double getBasecash() {
		return basecash;
	}

	public void setBasecash(double basecash) {
		this.basecash = basecash;
	}

	public double getReturncash() {
		return returncash;
	}

	public void setReturncash(double returncash) {
		this.returncash = returncash;
	}

}

适用的场景？

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

2、一个系统需要动态地在几种算法中选择一种。

3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
策略模式的优点？

1、策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。

2、简化了单元测试，因此每个算法都有自己的类，可以通过自己的接口单独测试。

Yu_Nan___
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaScript 设计模式——策略模式
Starry_Firmament的博客
12-29 2016
是一种行为设计模式，能让我们定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。
C++常见设计模式——策略模式
hang_1994的博客
12-13 987
设计模式是对设计原则的具体化。用江湖话说就是武林秘籍，总结出来的一些固定套路，可以帮助有根基的程序员迅速打通任督二脉，从此做什么都特别快。 C++常见设计模式——策略模式传统的策略模式实现使用函数指针实现策略模式 策略模式：定义了算法族，分别封装起来，让它们之间可以互相替换。此模式让算法的变化独立于使用算法的客户。 相比于使用大量的if…else，使用策略模式可以降低复杂度，使得代码更容易维护。 ...
Java 设计模式--策略模式
xiaoheiyou的博客
05-20 163
本设计模式资料源于慕课网,讲师:Geely 《Java设计模式精讲 Debug方式+内存分析》，本人作为自己手打整理作为学习的归纳总结。 一，模式介绍 1，定义和类型 定义：定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化不会影响到使用算法的用户 if…else… 类型：行为型 2，适用场景 系统有很多类，而他们的区别仅仅在于他们的行为不同 一个系统需要动态地在几种算法中悬着一种 3，优点 开闭原则 避免使用多重条件转移语句 提高算法的保密性和安全性 4，缺点 客户.
设计模式：策略模式
BoCong-Deng的博客
01-05 428
策略模式定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。策略模式是一种定义一系列算法的方法，从概念来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少各种算法类与使用算法类之间的耦合。 一、引 我们必须要真正理解模式的思路，才能在不同情况下选择合适的模式。我们使用模式的目的就是是代码层次思路清晰，并且尽...
策略模式（策略设计模式）详解
uzong
05-23 9357
策略模式（策略设计模式）详解 在现实生活中常常遇到实现某种目标存在多种策略可供选择的情况，例如，出行旅游可以乘坐飞机、乘坐火车、骑自行车或自己开私家车等，超市促销可以釆用打折、送商品、送积分等方法。 在软件开发中也常常遇到类似的情况，当实现某一个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能，如数据排序策略有冒泡排序、选择排序、插入排序、二叉树排序等。...
Java设计模式——策略模式
热门推荐
涛涛的个人博客
10-29 8万+
策略模式 1.策略模式简介 策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化 2.模式结构 策略模式包含如下角色： Strategy: 抽象策略类：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法（如下图的algorithm()） Context: 环境类 /上下文类： 上下文是依赖于接口的类（
设计模式——策略模式
努力努力再努力L
10-11 431
1. 模式定义和使用场景 2. 模式结构 3. 策略模式优点？ 4. 策略模式缺点？ 5. 策略模式代码实现
行为型设计模式——策略模式
庄小焱
11-12 1816
策略模式(strategy pattern): 定义了算法族, 分别封闭起来, 让它们之间可以互相替换, 此模式让算法的变化独立于使用算法的客户。
java设计模式——策略模式
u014627852的博客
07-06 465
编写鸭子项目，具体要求如下: 有各种鸭子(比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等)。 显示鸭子的信息。 传统方案解决鸭子问题的分析和代码实现 传统的设计方案(类图) 代码演示 package com.jinxu.strategy; public abstract class Duck { public Duck() { } public abstract void display();//显示鸭子信息 public void quack() { Syst
C++设计模式——策略模式(Strategy Pattern)
leonardohaig的博客
05-30 2366
C++设计模式——策略模式(Strategy Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——策略模式(Strategy Pattern)目录定义实现示例传统的策略模式实现使用函数指针实现策略模式工厂模式和策略模式对比总结参考资料 定义 Define a family of algorithms,encapsulate each one,and make them interchangeable. 定义一组算法，将每个算法都封装起来，并且使它们之间可以互换 策略模式是指定
设计模式——策略模式的学习与理解
12-20
什么是策略模式 通俗的来说。策略模式（ Strategy Pattern）就是将算法封装到具有共同接口的独立类中，以独立与客户端，客户端可以灵活的使用或替换算法族里面不同的算法，降低了耦合性。这种类型的设计模式属于行为...
设计模式——策略模式 & 单例模式
03-30
NULL 博文链接：https://maidoudao.iteye.com/blog/1329564
研磨设计模式之策略模式
02-27
 接下来想写写另外一个虽然较简单，但是使用很频繁的模式——策略模式策略模式(Strategy)1 场景问题1.1 报价管理向客户报价，对于销售部门的人来讲，这是一个非常重大、非常复杂的问题，对不同的客户要报不同的...
【ROS1转ROS2示例】
嵌入式行业打工人，不定期更新博客。
06-18 442
ROS1中的代码：人如果转ROS2，可以使用或者直接依赖于执行器(Executor)的循环来实现类似的功能。这里提供两种方法：方法一：使用。
设计模式原则——单一职责原则（SPS）
最新发布
luck_lsj的博客
06-22 933
设计模式原则——单一职责原则（SPS）
深入理解适配器模式：Java实现与框架应用
qq_40254606的博客
06-22 658
适配器模式（Adapter Pattern）是一种结构型设计模式，它将一个类的接口转换成另一个接口，以满足客户端的需求。适配器模式的关键在于适配器类，它负责将现有接口转换为客户端所期待的接口。// 定义MediaPlayer接口// 实现MediaPlayer接口的AudioPlayer类@Override// 内置支持mp3文件的播放// 使用MediaAdapter播放其他格式文件} else {
探索Java中的设计模式：从单例到工厂模式
技术研究中心
06-22 435
设计模式是解决软件设计中常见问题的可复用方案。它们提供了一套经过验证的解决方案，可以用来解决特定的设计问题。在面向对象的软件开发中，设计模式不仅可以提高代码的重用性和可维护性，还能增强系统的灵活性和可扩展性。通过本文的介绍，我们探索了Java中常见的设计模式，从单例模式到工厂模式，详细解释了它们的原理、实现方式以及适用场景。设计模式作为解决特定问题的成熟方案，能够在软件开发中帮助我们提高代码的质量和效率，提升系统的可维护性和扩展性。
Java多线程设计模式之保护性暂挂模式
weixin_42824596的博客
06-17 1121
多线程编程中，为了提高并发性，往往将一个任务分解为不同的部分。将其交由不同的线程来执行。这些线程间相互协作时，仍然可能会出现一个线程等待另一个线程完成一定的操作，其自身才能继续运行的情形。保护性暂挂模式（Guarded Suspension）可以帮助我们解决上述的等待问题。该模式的核心思想是如果某个线程执行特定的操作前需要满足一定的条件，则在该条件未满足时将该线程暂停运行（即暂挂线程，使其处于waiting状态，直到该条件满足时才继续运行）。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yu_Nan___

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值