优秀程序员早就学会用“状态模式”代替if-else了

2020年已经进入倒计时了，大家立好的flag完成了吗?2020实“鼠”不易，希望2021可以“牛”转乾坤。

简介

状态模式是行为型设计模式的一种。其设计理念是当对象的内部状态发生改变时，随之改变其行为。状态和行为之间是一一对应的。

该模式主要用于，对象的行为依赖于它的状态，并且其行为是随着状态的改变而切换时。

状态模式UML类图

类图讲解

State：抽象状态接口(也可以定义成抽象类)，该接口封装了所有状态所对应的行为。

ConcreteStateA/B：具体状态类，该类实现了抽象状态接口，会根据自身对应的状态来实现接口中定义的方法，还有另一个功能是指明如何过渡到下一个状态。

Context：环境(上下文)角色，该类负责状态的切换，还持有一个State实例，代表当前环境所处状态。

案例讲解

案例：通过状态模式来实现自助售卖机的功能。

状态接口

1. public interface State { 
2.   // 挑选商品 
3.   void choose(); 
4.   // 付款 
5.   boolean payment(); 
6.   // 分发商品 
7.   void dispenseCommodity(); 
8. } 

挑选商品状态类

1. public class ChooseGoods implements State { 
2.  
3.   VendingMachine machine; 
4.  
5.   public ChooseGoods(VendingMachine machine) { 
6.     this.machine = machine; 
7.   } 
8.  
9.   @Override 
10.   public void choose() { 
11.     if (machine.getCount() > 0) { 
12.       System.out.println("商品挑选成功，请及时付款！"); 
13.       machine.setState(machine.getPaymentState()); 
14.     } else { 
15.       System.out.println("很遗憾，商品售罄了！"); 
16.       machine.setState(machine.getEmptyState()); 
17.     } 
18.   } 
19.  
20.   @Override 
21.   public boolean payment() { 
22.     System.out.println("请先挑选商品！"); 
23.     return false; 
24.   } 
25.  
26.   @Override 
27.   public void dispenseCommodity() { 
28.     System.out.println("请先挑选商品！"); 
29.   } 
30. } 

付款状态类

1. public class PaymentState implements State { 
2.  
3.   VendingMachine machine; 
4.  
5.   public PaymentState(VendingMachine machine) { 
6.     this.machine = machine; 
7.   } 
8.  
9.   @Override 
10.   public void choose() { 
11.     System.out.println("商品已选购完成请勿重复挑选"); 
12.   } 
13.  
14.   @Override 
15.   public boolean payment() { 
16.     Random random = new Random(); 
17.     int num = random.nextInt(10); 
18.     if(num % 2 == 0){ 
19.       System.out.println("付款成功！"); 
20.       machine.setState(machine.getDispenseCommodityState()); 
21.       return true; 
22.     } 
23.     System.out.println("付款失败，请重新支付！"); 
24.     return false; 
25.   } 
26.  
27.   @Override 
28.   public void dispenseCommodity() { 
29.     System.out.println("请先完成支付！"); 
30.   } 
31. } 

商品售罄状态类

1. public class EmptyState implements State { 
2.  
3.   VendingMachine machine; 
4.  
5.   public EmptyState(VendingMachine machine) { 
6.     this.machine = machine; 
7.   } 
8.  
9.   @Override 
10.   public void choose() { 
11.     System.out.println("对不起商品已售罄！"); 
12.   } 
13.  
14.   @Override 
15.   public boolean payment() { 
16.     System.out.println("对不起商品已售罄！"); 
17.     return false; 
18.   } 
19.  
20.   @Override 
21.   public void dispenseCommodity() { 
22.     System.out.println("对不起商品已售罄！"); 
23.   } 
24. } 

分发商品状态类

1. public class DispenseCommodityState implements State { 
2.  
3.   VendingMachine machine; 
4.  
5.   public DispenseCommodityState(VendingMachine machine) { 
6.     this.machine = machine; 
7.   } 
8.  
9.   @Override 
10.   public void choose() { 
11.     System.out.println("请及时取走您的商品！"); 
12.   } 
13.  
14.   @Override 
15.   public boolean payment() { 
16.     System.out.println("请及时取走您的商品！"); 
17.     return false; 
18.   } 
19.  
20.   @Override 
21.   public void dispenseCommodity() { 
22.     System.out.println("请及时取走您的商品！"); 
23.     machine.setState(machine.getChooseGoods()); 
24.   } 
25. } 

自动售货机 => Context角色

1. public class VendingMachine { 
2.   // 表示当前状态 
3.   private State state = null; 
4.   // 商品数量 
5.   private int count = 0; 
6.   private State chooseGoods = new ChooseGoods(this); 
7.   private State paymentState = new PaymentState(this); 
8.   private State dispenseCommodityState = new DispenseCommodityState(this); 
9.   private State emptyState = new EmptyState(this); 
10.  
11.   public VendingMachine(int count) { 
12.     this.count = count; 
13.     this.state = this.getChooseGoods(); 
14.   } 
15.  
16.   // 购买商品 
17.   public void purchase() { 
18.     // 挑选商品 
19.     state.choose(); 
20.     // 支付成功 
21.     if (state.payment()) { 
22.       // 分发商品 
23.       state.dispenseCommodity(); 
24.     } 
25.   } 
26.    
27.   // 获取商品后将商品减一 
28.   public int getCount() { 
29.     return count--; 
30.   } 
31.    
32.   // get和set方法 ...  
33. } 

客户端测试类

1. public class Client { 
2.  
3.   public static void main(String[] args) { 
4.     VendingMachine machine = new VendingMachine(1); 
5.     for (int i = 1; i < 4; i++) { 
6.       System.out.println("第" + i + "次购买。"); 
7.       machine.purchase(); 
8.     } 
9.   } 
10. } 

执行结果

总结

1、状态模式将每个状态所对应的行为封装到一个类中，大大提高了代码的可读性。并且通过这样的设计还可以消除多余的if-else语句，方便代码的维护。

2、状态模式符合“开闭原则”，容易增加和删除状态。

3、任何事情都有利弊，状态模式也不例外。其最显著的问题是，每个状态都要对应一个类，当状态过多时会产生大量的类，从而加大维护成本。

4、应用场景：当一个需求有很多状态，并且状态之间会进行转换，不同状态还对应不同的行为时就可以考虑使用“状态模式”

原文地址：https://www.toutiao.com/a6910864621125583372/