使用策略模式简化你的if else代码

什么是策略模式

 

策略模式定义了一些列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。
策略模式让算法独立于使用它的客户而独立变换。复制代码

 

举个栗子：

假设要出去旅游，而出行的方式有很多，可以步行，坐火车，坐飞机等。而如果不使用任何设计模式，代码大概就是这样子：

 public class TravelStrategy {

        enum Strategy{
            WALK,PLANE,TRAIN
        }
        private Strategy strategy;
        public TravelStrategy(Strategy strategy){
            this.strategy=strategy;
        }

        public void travel(){
            if(strategy==Strategy.WALK){
                print("walk");
            }else if(strategy==Strategy.PLANE){
                print("plane");
            }else if(strategy==Strategy.TRAIN){
                print("train");
            }
        }

        public static void main(String[] args) {
            TravelStrategy walk=new TravelStrategy(Strategy.WALK);
            walk.travel();
            TravelStrategy plane=new TravelStrategy(Strategy.PLANE);
            plane.travel();
            TravelStrategy train=new TravelStrategy(Strategy.TRAIN);
            train.travel();
        }
    }

 

这样做有一个致命的缺点，一旦出行的方式增加就不得不增加新的if else，而这违反了开闭原则，如果我们使用策略模式则可以解决大量使用if else问题。

首先，定义策略接口

public interface Strategy {
  void travel();
}

然后根据不同的出行方式实行策略接口

    public class WalkStrategy implements Strategy{
        @Override
        public void travel() {
            System.out.println("walk");
        }
    }

    public class PlaneStrategy implements Strategy{
        @Override
        public void travel() {
            System.out.println("plane");
        }
    }

    public class TrainStrategy implements Strategy{
        @Override
        public void travel() {
            System.out.println("train");
        }
    }

此外还需要一个包装策略的类，并调用策略接口中的方法

     public class TravelContext {

        Strategy strategy;
        public Strategy getStrategy() {
            return strategy;
        }
        public void setStrategy(Strategy strategy) {
            this.strategy = strategy;
        }
        public void travel() {
            if (strategy != null) {
                strategy.travel();
            }
        }
    }

     public class Test {

        public static void main(String[] args) {
            TravelContext travelContext=new TravelContext();
            travelContext.setStrategy(new PlaneStrategy());
            travelContext.travel();
            travelContext.setStrategy(new WalkStrategy());
            travelContext.travel();
            travelContext.setStrategy(new TrainStrategy());
            travelContext.travel();
        }
    }

可以看到，应用了策略模式后，如果想增加新的出行方式，完全不必要修改现有的类，只需要实现策略接口即可，这就是面向对象中的对扩展开放的原则。假设新增加自行车出行的方式，只需新增一个类即可。

    public class BikeStrategy implements Strategy{
        @Override
        public void travel() {
            System.out.println("bike");
        }
    }

之后设置策略

    public class Main {
        public static void main(String[] args) {
            TravelContext travelContext=new TravelContext();
            travelContext.setStrategy(new BikeStrategy());
            travelContext.travel();
        }
    }