23模式之: 策略模式demo

一般写法:

package strategy_mode;

/**
 * 实现起来比较容易,符合一般开发人员的思路
 * 假如,类型特别多,算法比较复杂时,整个条件语句的代码就变得很长,难于维护.
 * 如果有新增类型,就需要频繁的修改此处的代码!
 * 不符合开闭原则!
 */
public class TestStrategy {
    
    
    /**
     * 根据类型,打折
     */
    public double getPrice(String type, double price){
        if ("普通客户小批量".equals(type)) {
            System.out.println("不打折,原价");
            return price;
        } else if ("普通客户大批量".equals(type)) {
            System.out.println("打九折");
            return price * 0.9;
        } else if ("老客户小批量".equals(type)) {
            System.out.println("打八五折");
            return price * 0.85;
        } else if ("老客户大批量".equals(type)) {
            System.out.println("打八折");
            return price * 0.8;
        }
        return price;
    }

}

 

策略接口:

package strategy_mode;

/**
 * 策略接口
 */
public interface Strategy {

    /**
     * 给标准价格打折
     */
    public double getPrice(double standardPrice);
    
}

 

新客户小批量:

package strategy_mode;

/**
 * 新客户小批量
 */
public class NewCustomerFewStrategy implements Strategy{

    
    /**
     * 标准价格, 不打折
     */
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("不打折,原价");
        return standardPrice;
    }

}

 

新客户大批量:

package strategy_mode;

/**
 * 新客户大批量
 */
public class NewCustomerManyStrategy implements Strategy{

    
    /**
     * 给标准价格打九折
     */
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打九折");
        return standardPrice * 0.9;
    }
    
}

 

老客户小批量:

package strategy_mode;

/**
 * 老客户小批量
 */
public class OldCustomerFewStrategy implements Strategy{

    
    /**
     * 给标准价格打八五折
     */
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打八五折");
        return standardPrice * 0.85;
    }
    
}

 

老客户大批量:

package strategy_mode;

/**
 * 老客户大批量
 */
public class OldCustomerManyStrategy implements Strategy{

    
    /**
     * 给标准价格打八折
     */
    @Override
    public double getPrice(double standardPrice) {
        System.out.println("打八折");
        return standardPrice * 0.8;
    }
    
}

 

管理策略类:

package strategy_mode;

/**
 * 负责管理策略类的类(Manager)
 * 负责和具体的策略类交互
 * 这样的话,具体的算法和直接的客户端调用分离了,使得算法可以独立于客户端独立的变化.
 * 如果使用spring的依赖注入功能,还可以通过配置文件,动态的注入不同策略对象,动态的切换不同的算法.
 */
public class Context {

    
    /**
     * 当前采用的算法对象
     */
    private Strategy strategy;
    
    
    /**
     * 1).可以通过构造器来注入
     */
    public Context(Strategy strategy){
        this.strategy = strategy;
    }

    
    /**
     * 2).可以通过set方法来注入
     */
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    
    
    /**
     * 打印报价(具体业务)
     * 根据当前策略,执行该策略所对应的计算方法
     * 不同策略,执行不同的计算方法
     */
    public void printPrice(double standardPrice) {
        double resultPrice = this.strategy.getPrice(standardPrice);
        System.out.println("您该报价: " + resultPrice);
    }
    
}

 

测试类:

package strategy_mode;

public class Client {

    public static void main(String[] args) {
        //创建Manager, 管理策略类(需要传入)
        Context ctx = new Context(new OldCustomerManyStrategy());
        
        //调用Manager的具体方法, 负责根据当前的策略类, 计算出对应策略的报价
        ctx.printPrice(998);
    }
    
}

 

打印结果:

打八折
您该报价: 798.4000000000001

 

 

谢谢声明出处!

转自: http://www.cnblogs.com/gscq073240/articles/7103381.html