Độ phức tạp theo chu kỳ khi gọi cùng một phương thức nhiều lần

Nhờ có một câu hỏi tại Đánh giá mã, tôi đã có một chút bất đồng (về cơ bản là cơ hội để tìm hiểu điều gì đó) về chính xác Độ phức tạp Cyclomatic dành cho mã dưới đây.

public static void main(String[] args) {
    try {
        thro();
        thro();
        thro();
        thro();
        thro();
        thro();
        thro();
    }
    catch (NullPointerException e) {
    }
}

private static Random random = new Random();

public static void thro() throws NullPointerException {
    if (random.nextBoolean())
        throw new NullPointerException();
    System.out.println("No crash this time");
}

Khi viết mã này trong Eclipse và sử dụng plugin số liệu Eclipse , nó cho tôi biết rằng Độ phức tạp theo chu kỳ McCabe cho phương thức chính là 2 và đối với throphương thức thì nó nói là 2.

Tuy nhiên, một người khác nói với tôi rằng sự phức tạp của việc gọi thronhiều lần là number of calls * method complexity, và do đó tuyên bố rằng độ phức tạp của phương thức chính là 7 * 2 = 14.

Có phải chúng ta đang đo những thứ khác nhau? Cả hai chúng ta có thể đúng không? Hoặc sự phức tạp chu kỳ thực tế ở đây là gì?

Khi tôi hiểu điều này một cách chính xác, Độ phức tạp theo chu kỳ mainlà 8 - đó là số lượng đường dẫn độc lập tuyến tính thông qua mã. Bạn có thể có một ngoại lệ tại một trong bảy dòng, hoặc không, nhưng không bao giờ nhiều hơn một dòng. Mỗi "điểm ngoại lệ" có thể tương ứng chính xác với một đường dẫn khác nhau thông qua mã.

Tôi đoán khi McCabe phát minh ra số liệu đó, anh ta không có ngôn ngữ lập trình với ý định xử lý ngoại lệ.

Là 'người khác', tôi sẽ trả lời ở đây, và chính xác về những gì tôi nói (điều mà tôi không đặc biệt chính xác với các công thức khác).

Sử dụng ví dụ mã ở trên, tôi tính độ phức tạp chu kỳ là 8 và tôi có các nhận xét trong mã để hiển thị cách tôi tính toán điều đó. Để mô tả các đường dẫn, tôi sẽ xem xét một vòng lặp thành công thông qua tất cả các thro()cuộc gọi dưới dạng 'đường dẫn mã' chính '(hoặc' CP = 1 '):

public static void main(String[] args) {
  try {
             // This is the 'main' Code Path: CP = 1
    thro();  // this has a branch, can succeed CP=1 or throw CP=2
    thro();  // this has a branch, can succeed CP=1 or throw CP=3
    thro();  // this has a branch, can succeed CP=1 or throw CP=4
    thro();  // this has a branch, can succeed CP=1 or throw CP=5
    thro();  // this has a branch, can succeed CP=1 or throw CP=6
    thro();  // this has a branch, can succeed CP=1 or throw CP=7
    thro();  // this has a branch, can succeed CP=1 or throw CP=8
  }
  catch (NullPointerException e) {
  }
}

Vì vậy, tôi đếm 8 đường dẫn mã trong phương thức chính này, mà theo tôi là Độ phức tạp theo chu kỳ là 8.

Theo thuật ngữ Java, mỗi cơ chế để thoát một hàm tính đến mức độ phức tạp của nó, do đó, một phương thức có trạng thái thành công và, ví dụ, có thể có tới 3 ngoại lệ, có 4 đường dẫn thoát được ghi lại.

Độ phức tạp của một phương thức gọi hàm như vậy là:

CC(method) = 1 + sum (methodCallComplexity - 1)

Tôi nghĩ rằng những điều khác cần xem xét, là theo tôi, catchmệnh đề này không đóng góp vào sự phức tạp của phương thức, catchnó chỉ đơn giản là mục tiêu của một throwsnhánh và do đó, một khối bắt là mục tiêu của nhiều throws đếm 1 lần cho mỗi throw, và không chỉ một lần cho tất cả mọi thứ.