CashFactory工厂类
package cn;
import java.lang.reflect.Constructor;
import java.util.HashMap;
public class CashFactory {
private static CashSuper cashSuper;
private static HashMap m = new HashMap();
private static void initMap(){
m.put("CashNormal", "cn.beans.CashNormal");
m.put("CashRebate", "cn.beans.CashRebate");
m.put("CashReturn", "cn.beans.CashReturn");
}
public static CashSuper getInstance(String type){
initMap();
try {
String clazz;
//无参构造,用setter
clazz=m.get(type).toString();
cashSuper=(CashSuper)Class.forName(clazz).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return cashSuper;
}
public static CashSuper getInstance(String type, String[] parameters){
if (parameters==null){
return getInstance(type);
}
initMap();
try {
//带参构造
String clazz=m.get(type).toString();
//根据类名获取Class对象
Class cs = Class.forName(clazz);
//参数类型数组
Class[] parameterTypes=new Class[parameters.length];
for (int i=0;i<parameters.length;i++){
parameterTypes[i]=String.class;
}
//根据参数类型获取相应的构造函数
System.err.println(parameterTypes==null);
Constructor constructor=cs.getConstructor(parameterTypes);
//根据获取的构造函数和参数,创建实例
Object o=constructor.newInstance(parameters);
cashSuper = (CashSuper)o;
} catch (Exception e) {
e.printStackTrace();
}
return cashSuper;
}
}
CashSuper策略接口
package cn;
public interface CashSuper {
public String acceptCash(String costPrice);
}
CashContext策略上下文,衔接策略接口和调用策略的类
package cn.beans;
import cn.CashSuper;
public class CashContext {
private CashSuper cashSuper;
public CashContext(CashSuper cashSuper){
this.cashSuper=cashSuper;
}
//传递策略接口内容
public String acceptCash(String costPrice){
return cashSuper.acceptCash(costPrice);
}
}
CashNormal普通Cash类
package cn.beans;
import cn.CashSuper;
public class CashNormal implements CashSuper {
@Override
public String acceptCash(String costPrice) {
System.err.println("我是CashNormal的acceptCash中");
return costPrice;
}
}
CashRebate打折Cash类
package cn.beans;
import java.math.BigDecimal;
import cn.CashSuper;
public class CashRebate implements CashSuper{
private String rebate="1";
@Override
public String acceptCash(String costPrice) {
System.err.println("我在CashRebate的acceptCash中");
BigDecimal dcm = new BigDecimal(costPrice.toCharArray());
BigDecimal dcmRebate = new BigDecimal(rebate.toCharArray());
//保留两位小数
dcm = dcm.multiply(dcmRebate).setScale(2,BigDecimal.ROUND_HALF_UP);
return dcm.toString();
}
public CashRebate() {
super();
}
public CashRebate(String rebate) {
super();
this.rebate = rebate;
}
public void setRebate(String rebate) {
this.rebate = rebate;
}
}
CashReturn返利Cash类
package cn.beans;
import java.math.BigDecimal;
import cn.CashSuper;
public class CashReturn implements CashSuper {
private String cashCondition;
private String cashReturn;
public CashReturn(){
super();
}
public CashReturn(String cashCondition,String cashReturn){
super();
this.cashCondition=cashCondition;
this.cashReturn=cashReturn;
}
public void setCashCondition(String cashCondition) {
this.cashCondition = cashCondition;
}
public void setCashReturn(String cashReturn) {
this.cashReturn = cashReturn;
}
@Override
public String acceptCash(String costPrice) {
System.err.println("我在CashReturn的acceptCash中");
BigDecimal dcm = new BigDecimal(costPrice.toCharArray());
BigDecimal dcmCondition = new BigDecimal(cashCondition.toCharArray());
BigDecimal dcmReturn = new BigDecimal(cashReturn.toCharArray());
BigDecimal dcmTemp = new BigDecimal(0);
dcmTemp = dcm.divide(dcmCondition,0,BigDecimal.ROUND_DOWN);
dcmTemp = dcmReturn.multiply(dcmTemp);
dcm = dcm.subtract(dcmTemp);
return dcm.toString();
}
}
JUnit测试类
package junit.test;
import org.junit.Test;
import cn.CashFactory;
import cn.CashSuper;
import cn.beans.CashContext;
import cn.beans.CashNormal;
import cn.beans.CashRebate;
import cn.beans.CashReturn;
public class Test_Cash {
@Test public void test(){
//不打折
CashSuper cashSuper=CashFactory.getInstance("CashNormal");
CashContext cashContext = new CashContext(cashSuper);
String price = cashContext.acceptCash("1000");
System.err.println(price);
//打八折 setter
CashRebate cashRebate=(CashRebate)CashFactory.getInstance("CashRebate");
cashRebate.setRebate("0.8");
cashContext = new CashContext(cashRebate);
price = cashContext.acceptCash("1000");
System.err.println(price);
//满300返100 setter
CashReturn cashReturn = (CashReturn)CashFactory.getInstance("CashReturn");
cashReturn.setCashCondition("300");
cashReturn.setCashReturn("100");
cashContext = new CashContext(cashReturn);
price = cashContext.acceptCash("1000");
System.err.println(price);
System.err.println("................以下为带参构造.....................");
//满200返100 constructor
String [] paramReturn= {"200","100"};
cashReturn = (CashReturn)CashFactory.getInstance("CashReturn",paramReturn);
cashContext = new CashContext(cashReturn);
price = cashContext.acceptCash("1000");
System.err.println(price);
//打八五折 constructor
String [] paramRebate = {"0.85"};
cashRebate = (CashRebate)CashFactory.getInstance("CashRebate",paramRebate);
cashContext = new CashContext(cashRebate);
price = cashContext.acceptCash("1000");
System.err.println(price);
//不打折
CashNormal cashNormal = (CashNormal)CashFactory.getInstance("CashNormal",null);
cashContext = new CashContext(cashNormal);
price = cashContext.acceptCash("1000");
System.err.println(price);
}
}
分享到:
相关推荐
定义了算法族,分别封装起来,让它们之间可以相互替代,此模式让算法的变化独立于使用算法的客户。
策略模式StrategyPattern,通过实现鸭子的飞行策略以及叫声策略演示策略模式的具体实现!
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件开发中,我们经常遇到需要根据不同的条件或场景来执行不同算法的情况。策略模式提供了一种将算法族封装到各自独立的类中,并在运行时选择具体...
例如,一个电子商务网站可能有多种促销策略(如满减、折扣、买一赠一等),通过策略模式,可以方便地添加新的促销规则,或者在用户结账时根据条件动态选择最优惠的策略。 在`strategyPattern-master`这个压缩包中,...
利用策略模式在排序对象中封装不同的排序算法(包括冒泡排序、快速排序、合并排序等),用户输入一系列的数据,或从文件中读入所需数据, 输入数据类型的存储可结合泛型编程, 然后允许客户动态地选择上述某一种排序...
在`StrategyPattern.cpp`和`StrategyPattern.h`文件中,我们可以预期看到如下结构: `StrategyPattern.h`可能包含了策略接口的定义,例如: ```cpp // 策略接口 class Strategy { public: virtual ~Strategy() {} ...
AbstractFactoryPattern AdapterPattern IBridgePattern IBuilderPattern ChainOfResponsibilityPatte 日CommandPattern ICompositePattern IDecoratorPattern ...StrategyPattern TemplatePattern VisitorPattern
在提供的压缩包"StrategyPattern-Sample"中,我们可以预期找到以下几个关键部分: 1. **策略接口(Strategy Interface)**:例如命名为`AlgorithmInterface`,它声明了所有策略类必须实现的操作。例如: ```java ...
本资源是用VC6.0实现的行为模式,有八种:CommandPattern、MediatorPattern、MementoPattern、ObserverPattern、StatePattern、StrategyPattern、TemplatePattern、VisitorPattern。参考于《23种设计模式(C++).pdf》
在给定的压缩包文件中,包含了九种经典的设计模式示例,它们分别是:单例模式(Singleton)、策略模式(StrategyPattern)、适配器模式(AdapterPattern)、装饰者模式(DecoratorPattern)、抽象工厂模式...
以和平精英的特种作战模式为例,无论是工程兵还是医疗兵,都有射击这个...public class StrategyPattern { public static void main(String[] args) { Player player = new EngineeringCorps(new EngineeringCorps
├─02.ChainOfResponsibility │ ├─html │ ├─My2ChainOfResponsibility │ │ ├─bin │ │ │ └─Debug │ │ ├─obj │ │ │ └─Debug │ │ │ └─TempPE │ │ └─Properties │ └─...
`StrategyPattern`目录可能包含多个策略类和上下文类,用于实现策略的切换。 6. **适配器模式**:将一个类的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。`Adapter...
`StrategyPattern`目录可能包含了策略接口和具体的策略类。 6. **代理模式(Proxy)**:为其他对象提供一种代理以控制对这个对象的访问。在C++中,代理模式可以使用智能指针和虚函数来实现。`ProxyPattern`目录可能...
1. [策略模式](worthed/OriginBlog/blob/master/articles/StrategyPattern.md) 2. [模板方法](worthed/OriginBlog/blob/master/articles/TemplateMethodPattern.md) 3. [状态模式](worthed/OriginBlog/blob/master...
*状态模式*和*策略模式*在技术上是相同的(请参阅[设计模式](http://c2.com/cgi/wiki?StrategyPattern))。 因此,祖先项目[Strategy Generator](https://sourceforge.net/projects/strategygenerator/)已被...
`StrategyPattern.java`可能包含了一个策略接口和多个实现了不同策略的类。 10. 代理模式(Proxy):为其他对象提供一种代理以控制对这个对象的访问。`ProxyDemo.java`可能展示了如何创建代理对象以控制原对象的...
策略模式是一种行为设计模式,它使你能在运行时改变对象的行为。在软件设计中,我们经常遇到需要在...在压缩包文件`strategyPattern`中,可能包含了示例代码或者进一步的解释材料,帮助读者更好地理解和应用策略模式。