मैं निम्नलिखित कोड

Question

की "चक्रवात जटिलता" को कैसे कम करूं, मैं सोच रहा हूं कि निम्न कोड की चक्रवात जटिलता को कैसे कम किया जाए और यदि यह ऐसा कुछ भी है जिसे मुझे चिंतित होना चाहिए।

विधि ValuePojo.getSomething()

public class ValuePojo 
{ 
    private ValueTypeEnum type; 

    private BigDecimal value1; 

    private BigDecimal value2; 

    private BigDecimal value3; 

    public ValuePojo() 
    { 
     super(); 
    } 

    /** 
    * This method reports as "HIGH Cyclomatic Complexity" 
    * 
    * @return 
    */ 
    public BigDecimal getSomething() 
    { 
     if (this.type == null) 
     { 
      return null; 
     } 

     switch (this.type) 
     { 
      case TYPE_A: 
      case TYPE_B: 
      case TYPE_C: 
      case TYPE_D: 
       return this.value1; 

      case TYPE_E: 
      case TYPE_F: 
      case TYPE_G: 
      case TYPE_H: 
       return this.value2; 

      case TYPE_I: 
      case TYPE_J: 
       return this.value3; 
     } 

     return null; 
    } 
} 

Answer 1

cyclomatic जटिलता निर्धारित किया जाता है (कृपया चर नामकरण, इस दिया स्पष्टता के लिए इस सवाल में फिर से लिखा गया है के बारे में चिंता नहीं है) को देखें आपके कोड में निष्पादन की शाखाओं की संख्या से। if - else ब्लॉक, switch कथन - सभी आपके कोड की चक्रवात जटिलता में वृद्धि करते हैं और उचित कोड कवरेज सुनिश्चित करने के लिए आवश्यक परीक्षण मामलों की संख्या भी बढ़ाते हैं।

अपने कोड में जटिलता को कम करने के लिए, मैं तुम्हें case बयान है कि एक परिभाषित व्यवहार की जरूरत नहीं है और अपने switch बयान में एक default व्यवहार से बदलने निकालने का सुझाव देते हैं।

यहां एक और question स्टैक ओवरफ्लो पर है जो इस समस्या को संबोधित करता है।

Answer 2

यदि आपको वास्तव में चक्रवात जटिलता प्राप्त करने की आवश्यकता है, तो आप मानचित्र का उपयोग करने पर विचार कर सकते हैं। जाहिर है, आपके कार्यान्वयन में, इसे केवल एक बार बनाया और शुरू किया जाना चाहिए।

public BigDecimal getSomething() { 
     if (this.type == null) { 
      return null; 
     } 
     Map<Type,BigDecimal> map = new HashMap<Type,BigDecimal>(); 
     map.put(TYPE_A, value1); 
     map.put(TYPE_B, value1); 
     map.put(TYPE_C, value1); 
     map.put(TYPE_D, value1); 
     map.put(TYPE_E, value2); 
     map.put(TYPE_F, value2); 
     map.put(TYPE_G, value2); 
     map.put(TYPE_H, value2); 
     map.put(TYPE_I, value3); 
     map.put(TYPE_J, value3); 

     return map.get(type); 
    }