前言

当代码中出现多重if-else语句或者switch语句时。
弊端之一：如果这样的代码出现在多处，那么一旦出现需求变更，就需要把所有地方的if-else或者switch代码进行更改，要是遗漏了某一处，那么程序就会出错。
弊端之二：代码逻辑难以理解。

卫语句

卫语句(guard clauses) 特点是：其结果必须为真，程序才能执行下去，就是把复杂的条件表达式拆分成多个条件表达式，比如一个很复杂的表达式，嵌套了好几层的if-then-else语句，转换为多个if语句，实现它的逻辑，这多条的if语句就是卫语句。

卫语句的使用，并不能改变前言说的弊端：一旦需求更改，需要修改所有使用更改需求的if-else代码块。不过使用卫语句可以让自己或者代码维护人员很容易的了解代码的含义。

  1. public void findBoyfriend (Man man) {     
  2.     if (man.isUgly()) { 
  3.         System.out.println("本姑娘是外貌协会的资深会员");         
  4.         return; 
  5.     } 
  6.     if (man.isPoor()) { 
  7.         System.out.println("贫贱夫妻百事哀");         
  8.         return; 
  9.     } 
  10.     if (man.isBadTemper()) { 
  11.         System.out.println("银河有多远，你就给我滚多远");         
  12.         return; 
  13.     } 
  14.     System.out.println("可以先交往一段时间看看"); 
  15. }

策略模式

策略模式定义了一组算法，将它们逐个封装起来，并使它们可以相互替换。策略可以让算法独立于使用它们的客户而变化。

使用策略模式可以代替多重if-else和switch语句，让代码维护变得更加简单。
策略模式UML：
大量if-else重构：卫语句、策略模式、状态模式 - 图1

  • 环境(Context)角色：持有一个Strategy的引用
  • 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现
  • 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为

策略模式代码模板：

  1. package xyz.zeling.test.strategy.template;
  3. import xyz.zeling.test.strategy.template.base.Strategy;
  5. /**
  6.  * @description 环境角色
  7.  */
  8. public class Context {
  10.     /**
  11.      * 策略对象
  12.      */
  13.     private Strategy strategy;
  15.     /**
  16.      * @param strategy 具体策略对象
  17.      */
  18.     public Context(Strategy strategy) {
  19.         this.strategy = strategy;
  20.     }
  22.     /**
  23.      * @description 执行策略方法
  24.      * @date 2018年1月14日 下午8:43:31
  25.      */
  26.     public void contextInterface() {
  27.         strategy.strategyInterface();
  28.     }
  29. }
  31. package xyz.zeling.test.strategy.template.base;
  33. /**
  34.  * @description 抽象策略角色
  35.  */
  36. public interface Strategy {
  38.     /**
  39.      * @description 策略方法
  40.      * @date 2018年1月14日 下午8:41:00
  41.      */
  42.     void strategyInterface();
  43. }
  47. package xyz.zeling.test.strategy.template;
  49. import xyz.zeling.test.strategy.template.base.Strategy;
  51. /**
  52.  * @description 具体策略类A
  53.  */
  54. public class ConcreteStrategyA implements Strategy {
  56.     @Override
  57.     public void strategyInterface() {
  58.         // TODO Auto-generated method stub
  59.     }
  60. }
  63. package xyz.zeling.test.strategy.template;
  65. import xyz.zeling.test.strategy.template.base.Strategy;
  67. /**
  68.  * @description 具体策略类B
  69.  */
  70. public class ConcreteStrategyB implements Strategy {
  72.     @Override
  73.     public void strategyInterface() {
  74.         // TODO Auto-generated method stub
  75.     }
  76. }
  79. package xyz.zeling.test.strategy.template;
  81. import xyz.zeling.test.strategy.template.base.Strategy;
  83. /**
  84.  * @description 具体策略类C
  85.  */
  86. public class ConcreteStrategyC implements Strategy {
  88.     @Override
  89.     public void strategyInterface() {
  90.         // TODO Auto-generated method stub
  91.     }
  92. }

实例应用：水果有不同种类，每种水果对应不同价格，用策略模式实现。

  1. package xyz.zeling.test.strategy.demo.base;
  3. /**
  4.  * @description 抽象策略，水果接口
  5.  */
  6. public interface Fruit {
  7.     /**
  8.      * @description 输出对应价格
  9.      * @date 2018年1月14日 下午3:03:07
  10.      */
  11.     void price();
  12. }
  15. package xyz.zeling.test.strategy.demo;
  17. import xyz.zeling.test.strategy.demo.base.Fruit;
  19. /**
  20.  * @description 具体策略，苹果类
  21.  */
  22. public class Apple implements Fruit {
  24.     @Override
  25.     public void price() {
  26.         System.out.println("苹果的价格！");
  27.     }
  28. }
  32. package xyz.zeling.test.strategy.demo;
  34. import xyz.zeling.test.strategy.demo.base.Fruit;
  36. /**
  37.  * @description 具体策略，香蕉
  38.  */
  39. public class Banana implements Fruit {
  41.     @Override
  42.     public void price() {
  43.         System.out.println("香蕉的价格！");
  44.     }
  45. }
  48. package xyz.zeling.test.strategy.demo;
  50. import xyz.zeling.test.strategy.demo.base.Fruit;
  52. /**
  53.  * @description 具体策略，梨
  54.  */
  55. public class Pear implements Fruit {
  57.     @Override
  58.     public void price() {
  59.         System.out.println("梨的价格！");
  60.     }
  61. }
  63. package xyz.zeling.test.strategy.demo;
  65. import xyz.zeling.test.strategy.demo.base.Fruit;
  67. /**
  68.  * @description 策略环境，输出水果价格
  69.  */
  70. public class FruitPrice {
  72.     /**
  73.      * 策略对象
  74.      */
  75.     private Fruit fruit;
  77.     /**
  78.      * @param fruit 策略对象
  79.      */
  80.     public FruitPrice(Fruit fruit) {
  81.         this.fruit = fruit;
  82.     }
  84.     /**
  85.      * @description 输出水果价格
  86.      * @date 2018年1月14日 下午3:12:26
  87.      */
  88.     public void printFruitPrice() {
  89.         fruit.price();
  90.     }
  91. }
  93. 客户端
  94.     /**
  95.      * @description 使用策略模式:针对一组算法，将每一个算法封装到具有共同接口的独立的类
  96.      */
  97.     public static void useStrategy() {
  98.         // 具体使用策略
  99.         Fruit apple = new Apple();
  100.         // 将策略放入环境中并执行策略
  101.         new FruitPrice(apple).printFruitPrice();
  102.     }

状态模式

状态模式(State Pattern) ：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。

状态模式类图：
大量if-else重构：卫语句、策略模式、状态模式 - 图2

说明：

  • 环境(Context)角色，也成上下文：定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。这个具体状态类的实例给出此环境对象的现有状态
  • 抽象状态(State)角色：定义一个接口，用以封装环境（Context）对象的一个特定的状态所对应的行为
  • 具体状态(ConcreteState)角色：每一个具体状态类都实现了环境（Context）的一个状态所对应的行为

策略模式代码模板：

  1. package xyz.zeling.test.state.template.base;
  3. /**
  4.  * @description 抽象状态角色
  5.  */
  6. public interface State {
  8.     /**
  9.      * @description 处理方法
  10.      */
  11.     void handle();
  12. }
  15. package xyz.zeling.test.state.template;
  17. import xyz.zeling.test.state.template.base.State;
  19. /**
  20.  * @description 具体状态类A
  21.  */
  22. public class ConcreteStateA implements State {
  24.     @Override
  25.     public void handle() {
  26.         // TODO Auto-generated method stub
  27.     }
  28. }
  31. package xyz.zeling.test.state.template;
  33. import xyz.zeling.test.state.template.base.State;
  35. /**
  36.  * @description 具体状态类B
  37.  */
  38. public class ConcreteStateB implements State {
  40.     @Override
  41.     public void handle() {
  42.         // TODO Auto-generated method stub
  43.     }
  44. }
  47. package xyz.zeling.test.state.template;
  49. import xyz.zeling.test.state.template.base.State;
  51. /**
  52.  * @description 具体状态类C
  53.  */
  54. public class ConcreteStateC implements State {
  56.     @Override
  57.     public void handle() {
  58.         // TODO Auto-generated method stub
  59.     }
  60. }
  63. package xyz.zeling.test.state.template;
  65. import xyz.zeling.test.state.template.base.State;
  67. /**
  68.  * @description 状态模式，环境角色类
  69.  */
  70. public class Context {
  72.     /**
  73.      * 状态对象
  74.      */
  75.     private State state;
  77.     /**
  78.      * @description 设置状态
  79.      * @date 2018年1月14日 下午9:13:20
  80.      * @param state 具体状态
  81.      */
  82.     public void setState(State state) {
  83.         this.state = state;
  84.     }
  86.     /**
  87.      * @description 执行策略方法
  88.      * @date 2018年1月14日 下午8:43:31
  89.      */
  90.     public void request() {
  91.         state.handle();
  92.     }
  93. }

实例应用：橘子有不同颜色，状态不同的橘子颜色不同，用状态模式实现。

  1. package xyz.zeling.test.state.demo.base;
  3. /**
  4.  * @description 状态模式，状态接口
  5.  */
  6. public interface Orange {
  7.     /**
  8.      * @description 输出橘子的颜色
  9.      * @date 2018年1月14日 下午4:14:00
  10.      */
  11.     void printColor();
  12. }
  15. package xyz.zeling.test.state.demo;
  17. import xyz.zeling.test.state.demo.base.Orange;
  19. /**
  20.  * @description 状态1：红色外观的橘子
  21.  */
  22. public class RedOrange implements Orange {
  24.     @Override
  25.     public void printColor() {
  26.         System.out.println("My color is red!");
  27.     }
  28. }
  31. package xyz.zeling.test.state.demo;
  33. import xyz.zeling.test.state.demo.base.Orange;
  35. /**
  36.  * @description 状态2：青色的橘子
  37.  */
  38. public class CyanOrange implements Orange {
  40.     @Override
  41.     public void printColor() {
  42.         System.out.println("My color is cyan!");
  43.     }
  44. }
  48. package xyz.zeling.test.state.demo;
  50. import xyz.zeling.test.state.demo.base.Orange;
  52. /**
  53.  * @description 状态3：黄色的橘子
  54.  */
  55. public class YellowOrange implements Orange {
  57.     @Override
  58.     public void printColor() {
  59.         System.out.println("My color is yellow!");
  60.     }
  61. }
  67. package xyz.zeling.test.state.demo;
  69. import xyz.zeling.test.state.demo.base.Orange;
  71. /**
  72.  * @description 橘子状态管理器
  73.  */
  74. public class OrangeStateManage {
  76.     /**
  77.      * 橘子的状态
  78.      */
  79.     private Orange state;
  81.     /**
  82.      * @description 设置橘子的状态
  83.      * @date 2018年1月14日 下午4:21:36
  84.      * @param state
  85.      */
  86.     public void setState(Orange state) {
  87.         this.state = state;
  88.     }
  90.     /**
  91.      * @description 输出当前状态的橘子颜色
  92.      * @date 2018年1月14日 下午4:22:08
  93.      */
  94.     public void print() {
  95.         state.printColor();
  96.     }
  97. }
  104. //客户端
  106. /**
  107.      * @description 使用状态模式：状态模式，又称状态对象模式（Pattern of Objects for
  108.      *              States），
  109.      状态模式是对象的行为模式。状态模式允许一个对象在其内部状态改变的时候改变其行为。
  110.      这个对象看上去就像是改变了它的类一样
  111.      */
  112. public static void useState() {
  113.     // 具体使用状态
  114.     Orange cyanOrange = new CyanOrange();
  115.     // 创建环境
  116.     OrangeStateManage orangeStateManage = new OrangeStateManage();
  117.     // 设置状态并执行
  118.     orangeStateManage.setState(cyanOrange);
  119.     orangeStateManage.print();
  120. }

策略模式和状态模式的比较

  • 状态模式：这个模式就好比员工申请离职单的流程，离职单到直接上级，这个状态就是直接上级批示，等直接上级审阅之后，通过了就到下一个状态。这一个个状态对应不同的处理，这是有顺序要求的。
  • 策略模式：这个模式好比于你假期要出国游玩，有日本、美国、新加坡等国家，你每到一个国家就执行不同的游玩策略，可以先去日本，也可以先去美国，没有顺序要求。