1.圈复杂度的定义

         圈复杂度是由Thomas J. McCabe， Sr. 在1976年提出的概念，用于判断代码复杂度。圈复杂度（Cyclomatic complexity）又称为条件复杂度或循环复杂度，用于衡量要给模块判定结构的复杂程度；数量上表现为独立的现行的路径条数，也可理解为覆盖所有的可能情况的最少使用的测试用例数。

2.圈复杂度的计算方法        

圈复杂度的概念计算方法有3种。

        1）控制流程图

        一般来说，软件程序的流程分为三种：顺序、条件和循环。用流程图标识出所有分支，可以表示出所有的圈复杂度。如下如所示：       

         2）节点判定法

         一个比较简单的方法是：圈复杂度就是等于判定节点的数量加上1。在编程语言中国，条件判断if-else， swtich-case、for循环、while循环、三木运算符，都可以作为一个判定节点。（国内一些公司，比如华为等公司，就是这么计算的）

        样例如下：        

funciton complexityExample(param) {
    if(param > 0) {
        print(0);
    }
    else {
    
        print(1)
    }

    return param < -1 ：True ? False;
}

       可知，这段程序的圈复杂度为3+1= 4.

      3）点边计算法

     计算方法为C = E - N + 2P，其中， E为控制流图（需要的方法为1）中的边的数量，N为控制流图中的节点数量，P为独立组件的数目。

     可得，E为9， N为6，P为1，可得C为5。

3.圈复杂度的衡量标准

         一般来说，代码复杂度第，代码不一定好；但代码复杂度高，代码质量一定差。具体衡量标准如下：

4.降低圈复杂度的方法

      降低圈复杂度的方法为重构。但是，重构应该保持原有功能不变，并不断完成。

      降低圈复杂度方法如下;

      1）抽象配置；

      2）单一职责-提炼函数；

      3）合并条件；

      4）提取条件。

      同事，针对圈复杂度过于高的语句部分，可以提出来一个函数。

1.什么是代码圈复杂度？

圈复杂度(Cyclomatic Complexity)是一种代码复杂度的衡量标准，由 Thomas McCabe 于 1976年定义。它可以用来衡量一个模块判定结构的复杂程度，数量上表现为独立现行路径条数，也可理解为覆盖所有的可能情况最少使用的测试用例数。圈复杂度大说明程序代码的判断逻辑复杂，可能质量低且难于测试和维护。程序的可能错误和高的圈复杂度有着很大关系。

圈复杂度主要与分支语句（if、else、，switch 等）的个数成正相关。可以在图1中看到常用到的几种语句的控制流图（表示程序执行流程的有向图）。当一段代码中含有较多的分支语句，其逻辑复杂程度就会增加。在计算圈复杂度时，可以通过程序控制流图方便的计算出来。

2.采用圈复杂度去衡量代码的好处

1.指出极复杂模块或方法，这样的模块或方法也许可以进一步细化。

2.限制程序逻辑过长。

McCabe&Associates 公司建议尽可能使 V（G） <= 10。NIST（国家标准技术研究所）认为在一些特定情形下，模块圈复杂度上限放宽到 15 会比较合适。

因此圈复杂度 V（G）与代码质量的关系如下： 
V（G） ∈ [ 0 , 10 ]：代码质量不错； 
V（G） ∈ [ 11 , 15 ]：可能存在需要拆分的代码，应当尽可能想措施重构； 
V（G） ∈ [ 16 , ∞ )：必须进行重构；

3.方便做测试计划，确定测试重点。

许多研究指出一模块及方法的圈复杂度和其中的缺陷个数有相关性，许多这类研究发现圈复杂度和模块或者方法的缺陷个数有正相关的关系：圈复杂度最高的模块及方法，其中的缺陷个数也最多，做测试时做重点测试。

3.代码圈复杂度的计算方法

通常使用的计算公式是V(G) = e – n + 2 , e 代表在控制流图中的边的数量（对应代码中顺序结构的部分），n 代表在控制流图中的节点数量，包括起点和终点（1、所有终点只计算一次，即便有多个return或者throw；2、节点对应代码中的分支语句）。

增加圈复杂度的语句：在代码中的表现形式：在一段代码中含有很多的 if / else 语句或者其他的判定语句（if / else , switch / case , for , while , | | , ? , …）。

代码示例-控制流图

根据公式 V(G) = e – n + 2 = 12 – 8 + 2 = 6 ，上图的圈复杂段为6。

说明一下为什么n = 8，虽然图上的真正节点有12个，但是其中有5个节点为throw、return，这样的节点为end节点，只能记做一个。

4.可以降低圈复杂度的重构技术

1.Extract Method（提炼函数）

void printOwing(double previousAmount)
{
  Enumeration e = _orders.elements();
  double outstanding = previousAmount * 1.2;

  // print banner
  System.out.println ("* * * * * * * * * * * * * * * * * * * * * * *");
  System.out.println ("Customer Owes ");
  System.out.println (" * * * * * * * * * * * * * * * * * * * * * * *");

  // calculate outstanding
  while (e.hasMoreElements())
  {
    Order each = (Order) e.nextElement();
    outstanding += each.getAmount();
  }

  //print details
  System.out.println ("name:" +_name);
  System.out.println ("amount" + outstanding)
}

将这段代码放进一个独立函数中，并让函数名称解释该函数的用途

void printOwing(double previousAmount)
{
  printBanner();
  double  outstanding  =  getOutsta nding(previousAmount  *  1.2);
  printDetads(outstanding);
}

void printBanner0
{
   // print banner
.....
}

double getOutstanding(double initialValue)
{
  double result = initialValue;
  Enumeration e =  orders.elements();
  while (e.hasMoreElements())
  {
    Order each = (Order) e.nextElement();
     result += each.getAmount();
  }
  return result;
}

void printDetails (double outstanding)
 {
  //print details
...
}

2.Substitute Algorithm（替换你的算法）

String foundPerson(String[] people)
{
  for (int i = 0; i < people.length; i++)
  {
      if (people[i].equals ("Don"))
       return "Don";
      if (people[i].equals ("John"))
       return "John";
      if (people[i].equals ("Kent"))
       return "Kent";
  }
  return "";
}

将函数本体替换为另一个算法

String foundPerson(String[] people)
{
   List candidates = Arrays.asList(new String[]{"Don", "John","Kent"});
   for (int i=0; i<people.length; i++)
      if (candidates.contains(people[i]))
         return people[i];
  return "";
}

3.Decompose Conditional（分解条件式）

//分解前
if (date.before (SUMMER_START)  || date.after(SUMMER_END))
  charge = quantity * _winterRate  + winterServiceCharge;
else
  charge = quantity * _summerRate;

//分解后 你有一个复杂的条件语句,从if、else段落中分别提炼出独立函数
if (notSummer(date))
  charge = winterCharge(quantity);
else
  charge = summerCharge (quantity);

4.Consolidate Conditional Expression（合并条件式）

例子1

double disabilityAmount()
{
   if (_seniority < 2) return 0;
   if (_monthsDisabled > 12) return 0;
   if (_isPartTime) return 0;
   // compute the disability amount
...
}

//将这些判断合并为一个条件式，并将这个条件式提炼成为一个独立函数，函数名自注释
double disabilityAmount()
{
   if (isNotEligableForDisability()) return 0;
   // compute the disability amount
...
}

5.Consolidate Duplicate Conditional Fragments（合并重复的条件片断）

//在条件式的每个分支上有着相同的一段代码。
if (isSpecialDeal()) 
{
     total = price * 0.95;
     send();
}
else
{
     total = price * 0.98;
     send();
}

//将这段重复代码搬移到条件式之外，避免用拷贝粘贴的方式写重复代码
if (isSpecialDeal())
    total = price * 0.95;
else
    total = price * 0.98;
send();

6.Remove Control Flag（移除控制标记）

//当前代码使用标记变量，可读性差，容易出错
void checkSecurity(String[] people) {
    boolean found = false;
    for (int i = 0; i < people.length; i++) {
        if (! found) {
            if (people[i].equals ("Don")){
                sendAlert();
                found = true;
            }
            if (people[i].equals ("John")){
                   sendAlert();
                   found = true;
            }
        }
    }
}

//以break和return取代标记变量
void checkSecurity(String[] people) {
    for (int i = 0; i < people.length; i++) {     
        if (people[i].equals ("Don")){
            sendAlert();
            break;
        }
        if (people[i].equals ("John")){
            sendAlert();
            break;
        }
    }
}

7.Parameterize Method（令函数携带参数）

//若干函数做了类似的工作，但在函数本体中却包含了不同的值
Dollars baseCharge()
 {
    double result = Math.min(lastUsage(),100) * 0.03;
    if (lastUsage() > 100) {
        result += (Math.min (lastUsage(),200) - 100) * 0.05;
    };
    if (lastUsage() > 200) {
        result += (lastUsage() - 200) * 0.07;
    };
    return new Dollars (result);
}

//建立单一函数，以参数表达那些不同的值
Dollars baseCharge() 
{
    double result = usageInRange(0, 100) * 0.03;
    result += usageInRange (100,200) * 0.05;
    result += usageInRange (200, Integer.MAX_VALUE) * 0.07;
    return new Dollars (result);
}

int usageInRange(int start, int end) 
{
    if (lastUsage() > start) 
        return Math.min(lastUsage(),end) -start;
    else 
        return 0;
}

8.异常逻辑处理型重构方法

原则：尽可能地维持正常流程代码在最外层。
意思是说，可以写if-else语句时一定要尽量保持主干代码是正常流程，避免嵌套过深。
实现的手段有：减少嵌套、移除临时变量、条件取反判断、合并条件表达式等。

例子1

double getPayAmount(){
    double result;
    if(_isDead) {
        result = deadAmount();
    }else{
        if(_isSeparated){
            result = separatedAmount();
        }
        else{
            if(_isRetired){
                result = retiredAmount();
            else{
                result = normalPayAmount();
            }
        }
    }
    return result;

//重构后   要求梳理清楚逻辑
double getPayAmount(){
    if(_isDead) 
        return deadAmount();
 
    if(_isSeparated)
        return separatedAmount();
 
    if(_isRetired)
        return retiredAmount();
 
    return normalPayAmount();
}

例子2

public double getAdjustedCapital(){
    double result = 0.0;
    if(_capital > 0.0 ){
        if(_intRate > 0 && _duration >0){
            resutl = (_income / _duration) *ADJ_FACTOR;
        }
    }
    return result;
}

//第一步处理 减少嵌套和移除临时变量：
public double getAdjustedCapital(){
    if(_capital <= 0.0 ){
        return 0.0;
    }
    if(_intRate > 0 && _duration >0){
        return (_income / _duration) *ADJ_FACTOR;
    }
    return 0.0;
}

//根据优化原则（尽可能地维持正常流程代码在最外层），可以再继续重构：
public double getAdjustedCapital(){
    if(_capital <= 0.0 ){
        return 0.0;
    }
    if(_intRate <= 0 || _duration <= 0){
        return 0.0;
    }
 
    return (_income / _duration) *ADJ_FACTOR;
}

例子3

   /* 查找年龄大于18岁且为男性的学生列表 */
    public ArrayList<Student> getStudents(int uid){
        ArrayList<Student> result = new ArrayList<Student>();
        Student stu = getStudentByUid(uid);
        if (stu != null) {
            Teacher teacher = stu.getTeacher();
            if(teacher != null){
                ArrayList<Student> students = teacher.getStudents();
                if(students != null){
                    for(Student student : students){
                        if(student.getAge() > = 18 && student.getGender() == MALE){
                            result.add(student);
                        }
                    }
                }else {
                    logger.error("获取学生列表失败");
                }
            }else {
                logger.error("获取老师信息失败");
            }
        } else {
            logger.error("获取学生信息失败");
        }
        return result;
    }

典型的"箭头型"代码，最大的问题是嵌套过深，解决方法是异常条件先退出，保持主干流程是核心流程：

   /* 查找年龄大于18岁且为男性的学生列表 */
    public ArrayList<Student> getStudents(int uid){
        ArrayList<Student> result = new ArrayList<Student>();
        Student stu = getStudentByUid(uid);
        if (stu == null) {
            logger.error("获取学生信息失败");
            return result;
        }
 
        Teacher teacher = stu.getTeacher();
        if(teacher == null){
            logger.error("获取老师信息失败");
            return result;
        }
 
        ArrayList<Student> students = teacher.getStudents();
        if(students == null){
            logger.error("获取学生列表失败");
            return result;
        }
 
        for(Student student : students){
            if(student.getAge() > 18 && student.getGender() == MALE){
                result.add(student);
            }
        }
        return result;
    }

9.状态处理型重构方法（1）

double getPayAmount(){
    Object obj = getObj();
    double money = 0;
    if (obj.getType == 1) {
        ObjectA objA = obj.getObjectA();
        money = objA.getMoney()*obj.getNormalMoneryA();
    }
    else if (obj.getType == 2) {
        ObjectB objB = obj.getObjectB();
        money = objB.getMoney()*obj.getNormalMoneryB()+1000;
    }
}

重构后

double getPayAmount(){
    Object obj = getObj();
    if (obj.getType == 1) {
        return getType1Money(obj);
    }
    else if (obj.getType == 2) {
        return getType2Money(obj);
    }
}
 
double getType1Money(Object obj){
    ObjectA objA = obj.getObjectA();
    return objA.getMoney()*obj.getNormalMoneryA();
}
 
double getType2Money(Object obj){
    ObjectB objB = obj.getObjectB();
    return objB.getMoney()*obj.getNormalMoneryB()+1000;
}

10.状态处理型重构方法（1）

针对状态处理的代码，一种优雅的做法是用多态取代条件表达式(《重构》推荐做法)。

double getSpeed(){
    switch(_type){
        case EUROPEAN:
            return getBaseSpeed();
        case AFRICAN:
            return getBaseSpeed()-getLoadFactor()*_numberOfCoconuts;
        case NORWEGIAN_BLUE:
            return (_isNailed)?0:getBaseSpeed(_voltage);
    }
}

重构后

class Bird{
    abstract double getSpeed();
}
 
class European extends Bird{
    double getSpeed(){
        return getBaseSpeed();
    }
}
 
class African extends Bird{
    double getSpeed(){
        return getBaseSpeed()-getLoadFactor()*_numberOfCoconuts;
    }
}
 
class NorwegianBlue extends Bird{
    double getSpeed(){
        return (_isNailed)?0:getBaseSpeed(_voltage);
    }
}

11.case语句重构方法（1）

https://www.cnblogs.com/wahaha02/p/7435603.html

Cyclomatic Complexity

1. 概念

　　a. 圈复杂度是一种衡量代码复杂程度的标准。

　　b. 圈复杂度高的害处：

　　　　圈复杂度大说明代码的判断逻辑复杂，可能质量低；

　　　　需要的更多的测试用例，难于测试和维护；

　　　　程序的可能错误和高的圈复杂度有着很大关系。

　　c. 圈复杂度的表现：

　　　　代码中分支循环语句多（if/else, switch/case, for, while），圈复杂度与分支循环语句个数正相关；

　　　　表达式复杂（含有三元运算符 ）。

2. 圈复杂度的计算方法

（1）圈复杂度可以通过程序控制流图计算，公式为：V(G) = e + 2 - n

　　e : 控制流图中边的数量

　　n : 控制流图中节点的数量(包括起点和终点；所有终点只计算一次，多个return和throw算作一个节点)

（2）圈复杂度对应程序控制流图中从起点到所有终点的路径的条数，所以页可以通过数路径的方式获得圈复杂度。

3. 圈复杂度计算实例

private int CalculateScore(int culture, String nation, boolean extend) {
        int result = 0;
        if (culture < 0) {
            throw new RuntimeException("分数不能小于0");
        } else if (culture < 200) {
            return culture;
        } else {
            switch (nation){
            case "汉":
                result = 0;
                break;
            case "蒙":
            case "回":
            case "维":
            case "藏":
                result = 10;
                break;
            default:
                result = 20;
            }
        }
        
        if (extend) {
            result += 10; 
        }
        return result + culture;
        
    }

程序控制流图：

(1)   V(G) = 19 + 2 - 13 = 8; 

(2)   数路径：8条

4. 减小圈复杂度的方法

a. 提取函数 - 将独立业务或模块代码独立出来，封装为函数，通过函数名诠释代码作用，做到见名知意。

b. 替换算法 - 复杂算法会导致bug可能性的增加及可理解性/可维护性的降低，如果函数对性能要求不高，提倡使用简单明了的算法。

c. 分解条件式 - 复杂的条件表达式，使用函数进行封装

d. 合并条件式 - 将一系列得到相同结果的条件表达式合并，可以的话封装为函数

e. 合并重复的条件片段 - 不同条件的分支，有相同的处理，可以提炼出分支以外，或者封装为函数

f. 移除控制标记 - 使用控制标签作为条件的，使用break 和 return取代

g. 将查询函数和修改函数分离 - 单一职责原则，强调函数的复用性而不是多用性

h. 函数携带参数 - 使用带参函数，强调函数的复用性

i. 以明确函数取代参数 - 强调函数的功能的明确性
转自：

https://www.cnblogs.com/techroad4ca/archive/2015/12/02/5012406.html

简单计算方法：

count = 1

for +1

if + 0

if else +1

else +1

switch case + default - 1

while +1