对switch进行拆分重构，降低复杂度，6种方式

最新推荐文章于 2023-07-09 20:56:32 发布
置顶 最新推荐文章于 2023-07-09 20:56:32 发布
阅读量7.7k 收藏 26
点赞数 7
分类专栏： 一些常见问题的解决 文章标签： switch switch重构 switch降低复杂度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_create/article/details/107147765
版权

如何对switch进行拆分重构

在我们编写代码的时候，常常遇到许多if-else或者switch的情况，这种情况下如果分支过多，会导致我们的最大复杂度过大，可能在公司编代码的时候通过不了检测，我们可以对这些分支提取成方法单独存在，也只是能降低平均圈复杂度，最大还是无济于事，所以这里我写了6种方式来降低复杂度：
1、利用多态，也就是方法重写
2、方法重写加反射
3、纯反射
4、利用枚举、重写方法
5、利用方法内部类重写接口或者抽象方法
6、Lambda表达式（基于函数的匿名表达式）同5一样，利用Lambda来简化了写法

这6中方式我个人认为枚举更好，也清晰，lambda也不错

如果谁有更好的方法，欢迎指正分享

先来看一下普通的switch语句：

public class Test4 {

    public static void main(String[] args) {
        String type = "4";
        switch (type) {
            case "1":
                System.out.println("情况1");
                break;
            case "2":
                System.out.println("情况2");
                break;
            case "3":
                System.out.println("情况3");
                break;
            case "4":
                System.out.println("情况4");
                break;
            case "5":
                System.out.println("情况5");
                break;
            case "6":
                System.out.println("情况6");
                break;
            default:
        }
    }
}

这是一个普通的switch语句块，这里我列举了6个分支，default忽略，假设是几十个，甚至更多呢？这种情况我们就一直加case吗？不停地加case会不停地破坏原来的代码，当复杂度上去了之后，维护起来也麻烦，眼睛都给你看晕。

1、利用多态，也就是方法重写

利用map和抽象类，或者是接口，对于每种不同的情况重写具体的方法实现，这样就降低了方法中的复杂度，我们如果要添加新的分支条件，只需要实现抽象类或者接口的子类，重写方法内容，在向map中添加进当前的新增子类，就可以实现分支条件的扩展，缺点是子类过多。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static sun.misc.Version.print;

public class Test4 {
    public static Map<String, Case> caseMap1 = new HashMap<>();

    static {
        caseMap1.put("1", new Case1());
        caseMap1.put("2", new Case2());
        caseMap1.put("3", new Case3());
        caseMap1.put("4", new Case4());
        caseMap1.put("5", new Case5());
        caseMap1.put("6", new Case6());
    }

    public static void main(String[] args) {
        String type = "4";
        caseMap1.get(type).print();
    }

    public static abstract class Case {
        public abstract void print();
    }

    public static class Case1 extends Case {
        @Override
        public void print() {
            System.out.println("情况1");
        }
    }

    public static class Case2 extends Case {
        @Override
        public void print() {
            System.out.println("情况2");
        }
    }

    public static class Case3 extends Case {
        @Override
        public void print() {
            System.out.println("情况3");
        }
    }

    public static class Case4 extends Case {
        @Override
        public void print() {
            System.out.println("情况4");
        }
    }

    public static class Case5 extends Case {
        @Override
        public void print() {
            System.out.println("情况5");
        }
    }

    public static class Case6 extends Case {
        @Override
        public void print() {
            System.out.println("情况6");
        }
    }
}

2、方法重写加反射

其实这个和第一个本质上没有什么区别，区别就是这种方式，是在调用时才去构造相应的对象

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static sun.misc.Version.print;

public class Test4 {
    public static Map<String, Class<? extends Case>> caseMap = new HashMap<>();
    
    static {
        caseMap.put("1", Case1.class);
        caseMap.put("2", Case2.class);
        caseMap.put("3", Case3.class);
        caseMap.put("4", Case4.class);
        caseMap.put("5", Case5.class);
        caseMap.put("6", Case6.class);
    }

    public static void main(String[] args) {
        String type = "4";
        factory(type).ifPresent(Case::print);
    }

    public static Optional<Case> factory(String type) {
        try {
            return Optional.of(caseMap.get(type).newInstance());
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
            //exception
            System.out.println("异常");
            return Optional.empty();
        }
    }

    public static abstract class Case {
        public abstract void print();
    }

    public static class Case1 extends Case {
        @Override
        public void print() {
            System.out.println("情况1");
        }
    }

    public static class Case2 extends Case {
        @Override
        public void print() {
            System.out.println("情况2");
        }
    }

    public static class Case3 extends Case {
        @Override
        public void print() {
            System.out.println("情况3");
        }
    }

    public static class Case4 extends Case {
        @Override
        public void print() {
            System.out.println("情况4");
        }
    }

    public static class Case5 extends Case {
        @Override
        public void print() {
            System.out.println("情况5");
        }
    }

    public static class Case6 extends Case {
        @Override
        public void print() {
            System.out.println("情况6");
        }
    }
}

3、纯反射

这种方式和前两种就有区别了，这种就是利用反射机制直接去执行方法

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static sun.misc.Version.print;

public class Test4 {
    public static Map<String, Method> caseMap2 = new HashMap<>();

    static {
        try {
            caseMap2.put("1", Test4.class.getMethod("case1"));
            caseMap2.put("2", Test4.class.getMethod("case2"));
            caseMap2.put("3", Test4.class.getMethod("case3"));
            caseMap2.put("4", Test4.class.getMethod("case4"));
            caseMap2.put("5", Test4.class.getMethod("case5"));
            caseMap2.put("6", Test4.class.getMethod("case6"));
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
            System.out.println("异常");
        }
    }

    public static void main(String[] args) {
        String type = "4";
        execute(type);
    }
    
    public static void execute(String type) {
        if (caseMap2.get(type) != null) {
            try {
                caseMap2.get(type).invoke(Test4.class.newInstance());
            } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) {
                //exception
                e.printStackTrace();
                System.out.println("异常");
            }
        }
    }
    
    public void case1() {
        System.out.println("情况1");
    }

    public void case2() {
        System.out.println("情况2");
    }

    public void case3() {
        System.out.println("情况3");
    }

    public void case4() {
        System.out.println("情况4");
    }

    public void case5() {
        System.out.println("情况5");
    }

    public void case6() {
        System.out.println("情况6");
    }
}

4、利用枚举、重写方法

这种方式就是我们在枚举中定义一个抽象方法，对于每个不同的情况进行重写方法，大家平常用的最多的可能就是把枚举当做常量来使用，其实枚举也是有构造方法，也是存在变量，方法的，其实这完全就是个类嘛，只是它对于不同的情况需要直接先在枚举内部构造出来而已

package com.company;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static sun.misc.Version.print;

public class Test4 {
    public static Map<String, CaseEnum> caseMap3 = new HashMap<>();

    static {
        caseMap3.put("1", CaseEnum.CASE1);
        caseMap3.put("2", CaseEnum.CASE2);
        caseMap3.put("3", CaseEnum.CASE3);
        caseMap3.put("4", CaseEnum.CASE4);
        caseMap3.put("5", CaseEnum.CASE5);
        caseMap3.put("6", CaseEnum.CASE6);
    }

    public static void main(String[] args) {
        String type = "4";
        caseMap3.get(type).print();
    }

    public enum CaseEnum {
        CASE1() {
            @Override
            public void print() {
                System.out.println("情况1");
            }
        },
        CASE2() {
            @Override
            public void print() {
                System.out.println("情况2");
            }
        },
        CASE3() {
            @Override
            public void print() {
                System.out.println("情况3");
            }
        },
        CASE4() {
            @Override
            public void print() {
                System.out.println("情况4");
            }
        },
        CASE5() {
            @Override
            public void print() {
                System.out.println("情况5");
            }
        },
        CASE6() {
            @Override
            public void print() {
                System.out.println("情况6");
            }
        };

        public abstract void print();
    }
}

5、利用方法内部类重写接口

这种方式其实和单独每种情况去实现接口的子类异曲同工，只是这种情况省略了单独对父类的继承，而是针对每种不同的情况对对象进行方法重写，其实也相当于上面枚举的变种

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class Test4 {

    public static Map<String, Case> caseMap4 = new HashMap<>();

    static {
        caseMap4.put("1", new Case() {
            @Override
            public void print() {
                System.out.println("情况1");
            }
        });
        caseMap4.put("2", new Case() {
            @Override
            public void print() {
                System.out.println("情况2");
            }
        });
        caseMap4.put("3", new Case() {
            @Override
            public void print() {
                System.out.println("情况3");
            }
        });
        caseMap4.put("4", new Case() {
            @Override
            public void print() {
                System.out.println("情况4");
            }
        });
        caseMap4.put("5", new Case() {
            @Override
            public void print() {
                System.out.println("情况5");
            }
        });
        caseMap4.put("6", new Case() {
            @Override
            public void print() {
                System.out.println("情况6");
            }
        });

    }
    
    public static abstract class Case {
        public abstract void print();
    }
    
    public static void main(String[] args) {
        String type = "4";
        caseMap4.get(type).print();
    }
}

6、Lambda表达式（基于函数的匿名表达式）同5一样，利用Lambda来简化了写法

这种方式也就是利用了jdk8的新特性lambda来简化了内部类的写法，也就是new一个接口，实现接口具体方法的方式被简化了，但是要注意，接口里面只能有一个方法，这样利用箭头函数调用的时候，才会自动匹配到这个方法。这是lmbada的特性，箭头函数的括号里面可以写形参，参数名字可以不和接口形参的名字对应，但参数数量要和接口方法一一对应，在使用时，你传入的的值会按照顺序一一传入。例子：

public class Test4 {
    public static void main(String[] args) {
        getStudent().eat("苹果");
    }

    public static Student getStudent() {
        return (footName) -> {
            System.out.println("学生吃了一个：" + footName);
            return footName;
        };
    }

    public interface Student {
        public String eat(String foot);
    }
}

在这里插入图片描述

下面你可以看到定义了个Case7接口，接口里面有一个print方法，这个方法根据情况随便写，名字、返回、形参等随意，现在这个print方法就是我们要调用的，map中的value全部为Case7类的对象，我们在添加map数据时，去实现这个方法的具体内容，然后通过map的key键获取到对应的Case7对象，执行print方法，就会对应的执行我们在往map中装入数据时具体去实现的内容。
下面这段代码是本次提取swith的代码：

import java.util.HashMap;
import java.util.Map;

public class Test4 {
    public static Map<String, Case7> caseMap5 = new HashMap<>();

    static {
        caseMap5.put("1",()->{System.out.println("情况1");});
        caseMap5.put("2",()->{System.out.println("情况2");});
        caseMap5.put("3",()->{System.out.println("情况3");});
        caseMap5.put("4",()->{System.out.println("情况4");});
        caseMap5.put("5",()->{System.out.println("情况5");});
        caseMap5.put("6",()->{System.out.println("情况6");});
    }

    public static void main(String[] args) {
        String type = "4";
        caseMap5.get(type).print();
    }

    public interface Case7{
        public void print();
    }
}

最终7种情况打印的结果一致：
在这里插入图片描述

IT_CREATE
关注
专栏目录
重构指标之如何监控代码圈复杂度
2301_76741586的博客
03-14 260
软件应用在发展到适当时机，“重构”，是开发过程中不可避免需要进行的一项工作。重构代码，以适配当前模块设计之初未考虑到的多样化场景，并增加模块的可维护性、健壮性、可测试性。那么，如何明确重构的方向，以及量化重构的结果呢？代码圈复杂度可以是一个供选择的指标。下文介绍如何获取应用的代码圈复杂度做到线上监控，给到复盘程序复杂程度的数据支撑。
java 圈复杂度_关于Java：降低Switch语句的循环复杂度-Sonar
weixin_29062671的博客
02-24 1015
我想减少开关盒的圈复杂度我的代码是：public String getCalenderName() {switch (type) {case COUNTRY:return country == null ? name : country.getName() + HOLIDAY_CALENDAR;case CCP:return ccp == null ? name : ccp.getName() +...
C语言switch/case圈复杂度优化重构
weixin_30502157的博客
08-26 943
软件重构是改善代码可读性、可扩展性、可维护性等目的的常见技术手段。圈复杂度作为一项软件质量度量指标，能从一定程度上反映这些内部质量需求（当然并不是全部），所以圈复杂度往往被很多项目采用作为软件质量的度量指标之一。 C语言开发的项目中，switch/case代码块是一个很容易造成圈复杂度超标的语言特性，所以本文主要介绍下降低switch/case圈复杂度的重构方法（如下图）。switch圈复杂度优...
switch方法重构案例
大河塬
02-09 1659
面向对象语言开发过程中对于switch语句是很敏感的，大多数switch基本都可以通过多态方式进行重构，从而使程序获得较好的拓展能力，最近项目开发中遇到这样一个案例，在此分享一下。 重构前程序 Java代码 public void update(Request newReq){ Request existReq=dao.getExist(); Type _t
简单易懂读《重构》 - Switch Statement (switch语句过多)
Hermaeus Mora's Apocrypha
11-29 2142
少用switch语句，尽量用多态取代
【高质量代码系列2】switch 语句重构技巧总结
技术进阶之路
03-28 2960
switch 语句在日常开发中，常常用来根据不同的类型，执行不同的操作。如果类型很多，整个swtich代码会变得很臃肿，代码可扩展性、可阅读性都很差。针对这个问题，我们可以考虑使用多态来解决，将每个类型的行为封装到一个子类中。下面以加减等计算类型的操作为例说明这个问题 1public enum CalculateType { 2 3 ADD("add","加法"),SUB("sub","...
C#: switch语句的重构
weixin_33778778的博客
07-06 163
switch语句是我们日常工作中最常见也是争论最多的（goto被忽视的前提下）。在重构中也把switch语句看成是一种代码的坏味道。但如何改造现有的switch代码并在今后去避免呢？本文从两方面进行探讨。 1 类型转化 在不同的抽象层次上对于同一个对象可能会用不同的定义。举个简单的例子，在计算器中，用户输入的操作符号可能是字符型的，而程序内部实现的时候需...
【设计模式活用】之switch case重构案例精讲
秋夜无霜
11-21 5764
目前系统应用中，有一个业务功能模块，是提供一个页面查询结果接口，通过参数控制以调用查询不同接口数据集，并对查询结果集做相应处理，封装并返回调用方。但是，该方法体使用了switch case控制不同业务场景，造成方法体行数较长，而每次新增业务又需要变动该方法，存在冗余的代码。鉴于此，通过分析业务逻辑，并进行抽象封装。 1、案例再现 1.1、原始的switch case 业务代码逻辑 public...
c语言圈复杂度switch,软件度量-圈复杂度
weixin_32175665的博客
05-19 1895
最近在做ESLint规则配置，重新注意了下complexity规则，之前对该规则不够重视，理解有盲区，于是系统学习,这里mark下。概念循环复杂度 Cyclomatic complexity也称为条件复杂度或圈复杂度，是一种软件度量，是由老托马斯·J·麦凯布在1976年提出，用来表示程序的复杂度圈复杂度计算公式M = E − N + 2P其中E 为图中边的个数N 为图中节点的个数P 为连接组件的个...
PHP编程指南：降低复杂度提升代码质量
- 尽量减少if-elseif-else和switch语句的使用，以降低代码的嵌套深度。复杂的条件分支可能导致代码难以理解和测试。 - 可以通过重构，将条件判断转换为无条件的函数调用或模式匹配，减少代码的逻辑复杂性。 3. **...
圈复杂度metrics
02-25
通过分析压缩包中的"metrics"文件，我们可以获取到具体项目的圈复杂度指标，从而对代码进行更深入的分析和优化。这些度量数据对于团队的代码审查、持续集成和持续交付过程都是极其有价值的。通过持续监控和改进圈...
【Java Switch Case重构高手】：保持代码清晰，维护性更强的秘诀
[【Java Switch Case重构高手】：保持代码清晰，维护性更强的秘诀](https://img-blog.csdnimg.cn/7dfad362cbdc4816906bdcac2fd24542.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,...
优化switch 分支
浅浅C的博客
06-22 523
三种方式总结 1：传统的用法 优点：简单易读，效率高 缺点：当量很多的时候会造成方法很长，不易维护，可能修改其中某一个case会引起未知的错误 2：委托 优点：使用委托将公有的进行提取，减少代码量 缺点：加入字典后每次添加都需要在字典后手动添加一个子项。总是觉得别扭，效率稍微差点
用多态重构switch语句
pty_2007的专栏
10-06 7225
好吧，我这个菜鸟确实是常常在用面向过程的思想在考虑问题，在编写程序。现在我已经摈弃了自己对java语言个人的偏见，而是用平等公平的态度看待java和C++。他们各有千秋，各有乾坤的。 好吧，入正题。假设有这么个基类： public class Base { public Base(int arg){ this.arg = arg; } void show(){ switch(
C语言 使用数组代替switch分支语句降低圈复杂度
分享空间
02-27 3263
在一些公司使用C语言开发，对于圈复杂度有一定的要求，其中switch就是造成高圈复杂的原因之一，这里分享一种方法降低圈复杂，使用数组代替switch，直接上代码，代码简单明了，如果发现代码中有问题或者疑惑可以提出来一同讨论。在实际的应用中需要自己去摸索，根据不同的场景，数据结构（结构体）会有所不同。#include &lt;stdio.h&gt; #include &lt;string.h&gt;...
浅谈：重复的switch语句如何优化
清晨qc的博客
07-09 1277
switch 语句是 Java 中用于多重条件判断的常见结构之一。然而，当我们在代码中遇到多个重复的 switch 语句时，会导致代码冗长、难以维护，并且效率低下。在本篇博客中，我将分享一些技巧和最佳实践，帮助您优化重复的 Switch 语句，提高 Java 代码的效率。
重构—改善代码既有设计 之switch/case使用
zhangweikai的专栏
03-24 5932
Switch / Case如下，假设Employee类中有这样两个方法: PayAmount. 根据员工类型获得员工的薪水:         public int PayAmount(EmployeeType empType)         {             switch (empType)             {                 case Empl
电子商务之价格优化算法：梯度下降：机器学习在价格优化中的角色.docx
最新发布
11-05
电子商务之价格优化算法：梯度下降：机器学习在价格优化中的角色.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值