过多if-else分支的优化

JAVA程序经常看到一个函数中包含了十几个if-else的分支判断
比如  根据不同职位增加工资的 例子

1. public class Employee {
   
2.     private int salary = 10;
   
3. 
   
4.     public void addMoney(String str) {
   
5.         if ("初级JAVA程序员".equals(str)) {
   
6.             this.salary = salary + 30;
   
7.         } else if ("中级JAVA程序员".equals(str)) {
   
8.             this.salary = salary + 50;
   
9.         } else if ("高级JAVA程序员".equals(str)) {
   
10.             this.salary = salary + 80;
    
11.         } else if ("架构师".equals(str)) {
    
12.             this.salary = salary + 100;
    
13.         } else if ("数据库管理员".equals(str)) {
    
14.             this.salary = salary + 100;
    
15.         } else if ("项目经理".equals(str)) {
    
16.             this.salary = salary + 100;
    
17.         } else if ("菜鸟".equals(str)) {
    
18.             this.salary = salary + 10;
    
19.         }
    
20.         // ...
    
21.         System.out.println(this.salary);
    
22.     }
    
23. 
    
24.     public static void main(String[] args) {
    
25.         Employee e = new Employee();
    
26.         e.addMoney("菜鸟");
    
27.     }
    
28. }

可以改写如下

1. import java.util.HashMap;
   
2. import java.util.Map;
   
3. 
   
4. public class Employee {
   
5.     private int salary = 10;
   
6. 
   
7.     private interface IStrategy {
   
8.         int addMoney();
   
9.     };
   
10. 
    
11.     Map<String, IStrategy> strategy = new HashMap<String, IStrategy>();
    
12. 
    
13.     {
    
14.         strategy.put("初级JAVA程序员", new IStrategy() {
    
15.             @Override
    
16.             public int addMoney() {
    
17.                 return 30;
    
18.             }
    
19.         });
    
20. 
    
21.         strategy.put("中级JAVA程序员", new IStrategy() {
    
22.             @Override
    
23.             public int addMoney() {
    
24.                 return 50;
    
25.             }
    
26.         });
    
27. 
    
28.         strategy.put("高级JAVA程序员", new IStrategy() {
    
29.             @Override
    
30.             public int addMoney() {
    
31.                 return 80;
    
32.             }
    
33.         });
    
34. 
    
35.         strategy.put("架构师", new IStrategy() {
    
36.             @Override
    
37.             public int addMoney() {
    
38.                 return 100;
    
39.             }
    
40.         });
    
41. 
    
42.         strategy.put("数据库管理员", new IStrategy() {
    
43.             @Override
    
44.             public int addMoney() {
    
45.                 return 100;
    
46.             }
    
47.         });
    
48. 
    
49.         strategy.put("项目经理", new IStrategy() {
    
50.             @Override
    
51.             public int addMoney() {
    
52.                 return 100;
    
53.             }
    
54.         });
    
55. 
    
56.         strategy.put("菜鸟", new IStrategy() {
    
57.             @Override
    
58.             public int addMoney() {
    
59.                 return 10;
    
60.             }
    
61.         });
    
62. 
    
63.     }
    
64. 
    
65.     public void addMoney(String str) {
    
66.         this.salary = salary + strategy.get(str).addMoney();
    
67.         System.out.println(this.salary);
    
68.     }
    
69. 
    
70.     public static void main(String[] args) {
    
71.         Employee e = new Employee();
    
72.         e.addMoney("菜鸟");
    
73.     }
    
74. }

如果是复杂的项目,可以把匿名内部类改为普通类.

改写之后,无论新增或者删除逻辑,都非常的简单明了,并且逻辑的变更,限制在了一个较小的范围.
实现了高内聚,低耦合的设计思路.