Java 策略模式

策略模式

特点

• 策略模式定义了一系列的算法，并将每一个算法封装起来，它们之间可以互相替换。

• 当遇到一个问题多种解决时，最简单的方式是利用if-else或switch-case根据不同判断选择不同方案，但这种方式代码耦合性太高、代码臃肿、难以维护等，这时可以利用策略模式将各种方案分离开，根据具体需求选择不同的策略方案。

角色介绍

• Context：操作策略的上下文环境。
• Strategy：抽象策略。
• ConcreteStrategy：具体策略方案。

代码实现

使用传统if-else方式

public class PriceCalculator {
    public static final int TYPE_BUS = 1;
    public static final int TYPE_SUBWAY = 2;

    /**
     * 公交车计费
     * 10km以内1元钱，超过10km部分每5km加1元
     */
    private int busPrice(int km) {
        int price = 1;
        //超出10km的距离
        int extraTotal = km - 10;
        int extraParts = extraTotal / 5;
        extraParts = extraTotal % 5 > 0 ? ++extraParts : extraParts;
        price += extraParts * 1;
        return price;
    }

    /**
     * 地铁计费
     * 6km（含）以内3元，6-12（含）km4元，12-22km（含）5元，22-32km（含）6元，其他距离7元
     */
    private int sbuwayPrice(int km) {
        if (km <= 6) {
            return 3;
        } else if (km > 6 && km <= 12) {
            return 4;
        } else if (km > 12 && km <= 22) {
            return 5;
        } else if (km > 22 && km <= 32) {
            return 6;
        } else {
            return 7;
        }
    }

    public int calculatorPrice(int km, int type) {
        if (type == TYPE_BUS) {
            return busPrice(km);
        } else if (type == TYPE_SUBWAY) {
            return sbuwayPrice(km);
        } else {
            return 0;
        }
    }
}

使用

public class Demo {
    public static void main(String[] args) {
        PriceCalculator calculator = new PriceCalculator();
        System.out.println(calculator.calculatorPrice(16, PriceCalculator.TYPE_SUBWAY));//5
        System.out.println(calculator.calculatorPrice(16, PriceCalculator.TYPE_BUS));//3
    }
}

使用策略模式优化

策略接口

interface CalculateStrategy {
    int calculatePrice(int km);
}

具体策略

public class BusStrategy implements CalculateStrategy {
    @Override
    public int calculatePrice(int km) {
        /**
         * 公交车计费
         * 10km以内1元钱，超过10km部分每5km加1元
         */
        int price = 1;
        //超出10km的距离
        int extraTotal = km - 10;
        int extraParts = extraTotal / 5;
        extraParts = extraTotal % 5 > 0 ? ++extraParts : extraParts;
        price += extraParts * 1;
        return price;
    }
}

public class SubwayStrategy implements CalculateStrategy {
    @Override
    public int calculatePrice(int km) {
        /**
         * 地铁计费
         * 6km（含）以内3元，6-12（含）km4元，12-22km（含）5元，22-32km（含）6元，其他距离7元
         */
        if (km <= 6) {
            return 3;
        } else if (km > 6 && km <= 12) {
            return 4;
        } else if (km > 12 && km <= 22) {
            return 5;
        } else if (km > 22 && km <= 32) {
            return 6;
        } else {
            return 7;
        }
    }
}

操作策略的上下文对象

public class TrafficCalculator {
    CalculateStrategy calculator = null;

    public void setCalculator(CalculateStrategy calculator) {
        this.calculator = calculator;
    }

    public int calculatePrice(int km) {
        return calculator.calculatePrice(km);
    }
}

使用

public class Demo {
    public static void main(String[] args) {
        TrafficCalculator calculator = new TrafficCalculator();
        // calculator.setCalculator(new BusStrategy());
        calculator.setCalculator(new SubwayStrategy());
        System.out.println(calculator.calculatePrice(16));
    }
}

5