简单工厂模式和策略模式

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

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

         策略模式：比简单工厂模式多了一个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);

    }

}

 

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