简单工厂模式和策略模式

两种模式如出一辙，基本方式都是通过将相同的行为封装在一个抽象父类（或接口）中，然后子类继承该抽象父类并对该相同的行为进行不同的实现。

简单工厂模式：目的在于根据不同的条件创建不同的子类，工厂类的作用就是创建类。



策略模式：比简单工厂模式多了一个context类，该类中保持对一个策略父类的引用。该模式对策略类的方法调用进行封装，但在客户端还是要进行选择性地手工创建策略类并作为参数传入context.



还可以将工厂模式和策略模式结合使用，进一步客户端的选择创建子类放到context中。




CashStrategy抽象父类：
public
abstract class CashStrategy {
public
abstract double cashActive(double money);
}
CashRebateStrategy子类：

public
classCashRebateStrategy extends CashStrategy {
private
double rebate;
@Override
public
double cashActive(double money) {
return money *
rebate;
}
public CashRebateStrategy(double rebate) {
this.rebate = rebate;
}
//get set
}

CashReturnStrategy子类：

public
class CashReturnStrategy extends CashStrategy {
private
double returnCondition;
private
double returnCount;
@Override
public
double cashActive(double money) {
if(money >=
returnCondition){
return money - Math.floor(money/
returnCondition)*
returnCount;
}
return money;
}
public CashReturnStrategy(double returnCondition,double returnCount) {
this.returnCondition =returnCondition;
this.returnCount = returnCount;
}
//get set
}

CashNormalStrategy子类：

public
classCashNormalStrategy extends CashStrategy {
@Override
public
double cashActive(double money) {
return money;
}
}

StrategyFactoryContext上下文环境类：

public
classStrategyFactoryContext {
private CashStrategy
cashStrategy;
//仅使用策略模式的情况
//publicStrategyFactoryContext(CashStrategy cashStrategy) {
// this.cashStrategy= cashStrategy;
// }

// 结合简单工厂模式（使用构造器）
public StrategyFactoryContext(Stringselete) {
switch(selete){
case
"8折":
this.cashStrategy =
newCashRebateStrategy(0.8);
break;
case
"满300返100":
this.cashStrategy =
newCashReturnStrategy(300,100);
break;
default:
this.cashStrategy =
new CashNormalStrategy();
}
}
// 结合简单工厂模式（使用具体方法进行初始化）
// publicvoid createStrategyFactory(String
selete){
// //将swith放到构造器中可以进一步降低代码复杂度---不用调用方法.
// switch(selete){
// case"8折":
// this.cashStrategy= new CashRebateStrategy(0.8);
// break;
// case"满300返100":
// this.cashStrategy= new CashReturnStrategy(300,100);
// break;
// default:
// this.cashStrategy= new CashNormalStrategy();
// }
// }
// 封装了对相同行为的不同实现的调用
public
double contextInterface(double money){
return
cashStrategy.cashActive(money);
}
}

public
classTestClient {

public
static void main(String[] args) {
// StrategyFactoryContextcontext = new StrategyFactoryContext();
//
// context.createStrategyFactory("8折");
// doubleresult = context.contextInterface(100);
// System.out.println(result);
//
// context.createStrategyFactory("满300返100");
// doubleresult1 = context.contextInterface(700);
// System.out.println(result1);
//
// context.createStrategyFactory("");
// doubleresult2 = context.contextInterface(500);
// System.out.println(result2);

StrategyFactoryContextcontext = newStrategyFactoryContext("8折");
double result =context.contextInterface(100);
System.out.println(result);
}
}

具体实例就是在当前项目中，玩家可以选择将武将转化为经验书、金币等情况，其实就是不同的转化策略：