针对这些情况，一般做法也是在业务方法内，做个 if - else 判断，如果是第一步，则执行第一步的业务，如果是第二步，则执行第二步的业务，这种方式同场景 1 一样，代码也比较难看 。
对于这样的场景，我们同样可以使用设计模式来实现，因为每一步都是有关联的，执行完第一步，才能执行第二步，执行完第二步才能执行第三步，它很像一条链子将它们联系起来，所以很容易想到可以采用责任链模式 。
下面，请看具体的实现：
public abstract class Handler {protected Handler handler;public void setHandler(Handler handler) {this.handler = handler;}public abstract void handleRequest();}public class StepOneHandler extends Handler {@Overridepublic void handleRequest() {if(this.handler != null){this.copy(this.handler);this.handler.handleRequest();}else{//执行第一步的方法}}}public class StepOneHandler extends Handler {@Overridepublic void handleRequest() {if(this.handler != null){this.copy(this.handler);this.handler.handleRequest();}else{//执行第一步的方法}}}public class HandlerFactory {public static Handler create(int step){Handler handler = null;switch (request.getStep()){case 1:handler = new StepOneHandler();break;case 2:Handler stepTwoHandler = new StepTwoHandler();handler.setHandler(stepTwoHandler);break;default:break;}return handler;}public static void main(String[] args) {Handler handler = HandlerFactory.create(step);handler.handleRequest();}}业务类传入一个 step，通过 HandlerFactory 实例化 handler，通过 handler 就可以执行指定的步骤，同样地，增加一个步骤，业务类无需任何变动 。
场景 3：多重循环改造有些时候，我们会使用多重循环，直接带业务方法里写，看着很不优雅，就像这样：
for (int i = 0;i < list.size();i++){for (int j = 0;j < list.size();j++){for (int k = 0;k < list.size();k++){}}}我们可以将其进行封装改造，将循环细节封装起来，只将一些方法暴露给业务方调用：
public class Lists {public static void main(String[] args) {List<Object> list1 = new ArrayList<>();list1.add("1");list1.add("1");List<Object> list2 = new ArrayList<>();list2.add("2");list2.add("2");List<Object> list3 = new ArrayList<>();list3.add("3");list3.add("3");//通过这样的方式，使代码更加优雅，更加清晰，调用方无需理解循环细节Lists.forEach(list1,list2,list3).then(new Each() {@Overridepublic void test(Object... items) {System.out.println(items[0]+"t"+items[1]+"t"+items[2]);}});}private List[] lists;public static class Builder{private List[] lists;public Builder setLists(List[] lists){this.lists = lists;return this;}//通过构建者实例化Lists类public Lists build(){return new Lists(this);}}private Lists(Builder builder){this.lists = builder.lists;}/**** @param lists* @return*/public static Lists forEach(List...lists){return new Lists.Builder().setLists(lists).build();}public void then(Each each){if(null != lists && lists.length > 0){List list1 = lists[0];for (int i = 0;i < list1.size() ;i++){List list2 = lists[1];for(int j = 0;j < list2.size();j++){List list3 = lists[2];for(int k = 0;k < list3.size();k++){each.test(list1.get(i),list2.get(j),list3.get(k));}}}}}//设置观察者public interface Each{void test(Object...items);}}上面的 main 方法就是我们业务调用时需要调用的方法，可以看出，我们将循环细节封装到 Lists 里面，使调用方的代码更加优雅 。
此场景用到的设计模式有：构建者模式、观察者模式 。
场景 4：再见吧！if - else在实际应用中，我们看到最多的代码便是 if - else，这样的代码在业务场景中出现太多的话，看着就不太优雅了，前面的场景其实已经多次将 if - else 用设计模式替换，本场景，我将会用新的设计模式来替换讨厌的 if - else，那就是策略模式 。
策略模式，通俗点讲，就是根据不同的情况，采取不同的策略，我们把它转化成 if - else，即：
if(情况1){执行策略1}else if(情况2){执行策略2}我们用策略模式该怎么实现呢，请看代码：public interface Strategy {/*** 策略方法*/void strategyInterface();}public class ConcreteStrategyA implements Strategy{@Overridepublic void strategyInterface() {System.out.println("实现策略1");}}public class Context {//持有一个具体策略的对象private Strategy strategy;/*** 构造函数，传入一个具体策略对象* @param strategy具体策略对象*/public Context(Strategy strategy){this.strategy = strategy;}/*** 策略方法*/public void contextInterface(){strategy.strategyInterface();}public static void executeStrategy(int type){Strategy strategy = null;if(type == 1){strategy = new ConcreteStrategyA();}Context context = new Context(strategy);context.contextInterface();}public static void main(String[] args) {Context.executeStrategy(1);}}