【高质量代码系列2】switch 语句重构技巧总结

switch 语句在日常开发中，常常用来根据不同的类型，执行不同的操作。如果类型很多，整个swtich代码会变得很臃肿，代码可扩展性、可阅读性都很差。针对这个问题，我们可以考虑使用多态来解决，将每个类型的行为封装到一个子类中。

下面以加减等计算类型的操作为例说明这个问题

 1public enum CalculateType {
 2
 3    ADD("add","加法"),SUB("sub","减法"),MUL("mul","乘法");
 4
 5    private String type;
 6
 7    private String desc;
 8
 9    CalculateType(String type,String desc) {
10        this.type = type;
11        this.desc = desc;
12    }
13
14    public String getType() {
15        return type;
16    }
17
18    public void setType(String type) {
19        this.type = type;
20    }
21
22    public String getDesc() {
23        return desc;
24    }
25
26    public void setDesc(String desc) {
27        this.desc = desc;
28    }
29}
30
31
32public class Calculate {
33
34    public int calculate(int a, int b,CalculateType type) {
35        switch (type) {
36            case ADD:
37                return a + b;
38            case MUL:
39                return a * b;
40            case SUB:
41                return a - b;
42            default:
43                throw new UnsupportedOperationException("不支持的计算类型");
44        }
45    }
46}

calculate()方法利用switch语句这样的写法，后面一旦不断新增计算类型，代码就会变得越来越庞大。我们可以把加、减、乘三种算法独立成一个类，将具体的计算方法封装到类中。

 1public interface NumCalculate {
 2
 3    int calculate(int a, int b);
 4}
 5
 6public class AddCalculate implements NumCalculate{
 7
 8    @Override
 9    public int calculate(int a, int b) {
10        return a + b;
11    }
12}
13
14public class MulCalculate implements NumCalculate {
15
16    @Override
17    public int calculate(int a, int b) {
18        return a * b;
19    }
20}
21
22public class SubCalculate implements NumCalculate {
23
24    @Override
25    public int calculate(int a, int b) {
26        return a - b;
27    }
28}

这样当我们需要某项计算时，直接调用对应类的方法就可以了。
下面的问题就是如何获取对象，我们可以考虑使用反射根据类名来获取对象。

 1public class Calculate {
 2
 3    public static NumCalculate newInstance(String className) {
 4        try {
 5            Class action = Class.forName(className);
 6            NumCalculate calculate = (NumCalculate) action.newInstance();
 7            return calculate;
 8        } catch (Exception e) {
 9            return null;
10        }
11    }
12
13    public static void main(String[] args) throws Exception {
14
15        NumCalculate calculate = newInstance(AddCalculate.class.getName());
16        int result = calculate.calculate(1, 2);
17        System.out.printf(String.valueOf(result));
18    }
19
20}

这样当我们需要进行某种类型的计算时，只需知道对应的类名就可以获取对象，进而执行计算，完全不再需要swtich语句。

其实在我们的实际开发中，常常会遇到switch的应用，如果类型很多，代码很容易变得臃肿不堪，可考虑这种方式来重构！

更多内容欢迎关注个人微信公众号，一起成长！