Cyclomatic Complexity - V(G)

Methods with a high cyclomatic complexity tend to be more difficult to understand and maintain. In general the more complex the methods of an application, the more difficult it will be to test it, and this will adversely affect its reliability.

V(G) is a measure of the control flow complexity of a method or constructor. It counts the number of branches in the body of the method, defined as:

• while statements;
• if statements;
• for statements.

Lines of Code - LOC

This metric can also be used for sizing other constructs as well, for example, the overall size of a Java class or package can be measured by counting the number of source lines it consists of.

LOC can be used to determine the size of a compilation unit (source file), class or interface, method, constructor, or field. It can be configured to ignore:

• blank lines;
• lines consisting only of comments;
• lines consisting only of opening and closing braces.

Depth of Inheritance Hierarchy - DIT

A class that is deep within the tree inherits more methods and state variables, thereby increasing its complexity and making it difficult to predict its behavior. It can be harder to understand a system with many inheritance layers.

DIT is defined for classes and interfaces:

• all interface types have a depth of 1;
• the class java.lang.Object has a depth of 1;
• all other classes have a depth of 1 + the depth of their super class.

Number of Attributes - NOA

In Java, state can be exposed to subclasses through protected fields, which entails that the subclass also be aware of and maintain any invariants. This interference with the class's data encapsulation can be a source of defects and hidden dependencies between the state variables.

• the class itself;
• a class or interface that the class extends or implements;
• a class or method that extends the class.

Number of Local Methods - NLM

Weighted Methods per Class - WMC

The subclasses of a class inherit all of its public and protected methods, and possibly its package methods as well, so the number of methods a class has directly impacts the complexity of its subclasses. Classes with large numbers of methods are often specific to a particular application, reducing the ability to reuse them.

The definition of WMC is based upon NLM, and it provides the same configuration parameters for counting inherited methods and of varying visibility. The main difference is that NLM always counts each method as 1, whereas WMC will weight each method. There are two weighting schemes:

• V(G) the cyclomatic complexity of the method is used as its weight. Methods from class files are given a V(G) of 1.
• the arity, or the number of parameters of the method are used to determine the weight.

Response For Class - RFC

One reason for this is that if a method call on a class can result in a large number of different method calls on the target and other classes, then it can be harder to test the behavior of the class and debug problems. It will typically require a deeper understanding of the potential interactions that objects of the class can have with the rest of the system.

Fan Out - FANOUT

• field declarations;
• formal parameters and return types;
• throws declarations;
• local variables.

Coupling Between Objects - CBO

A high value of coupling reduces the modularity of the class and makes reuse more difficult. The more independent a class is the more likely it is that it will be possible to reuse it in another part of the system. When a class is coupled to another class it becomes sensitive to changes in that class, thereby making maintenance for difficult. In addition, a class that is overly dependent on other classes can be difficult to understand and test in isolation.

CBO is defined for classes and interfaces, constructors and methods. It counts the number of reference types that are used in:

• field declarations
• formal parameters and return types
• throws declarations
• local variables

• types from which field and method selections are made

Lack of Cohesion Of Methods - LCOM

Another form of cohesion that is useful for Java programs is cohesion between nested and enclosing classes. A nested class that has very low cohesion with its enclosing class would probably better designed as a peer class rather than a nested class.

LCOM is defined for classes. Operationally, LCOM takes each pair of methods in the class and determines the set of fields they each access. If they have disjoint sets of field accesses increase the count P by one. If they share at least one field access then increase Q by one. After considering each pair of methods, LCOM = (P > Q) ? (P - Q) : 0

If the number of classes in the system can be projected during the initial design phase of the project it can serve as a base for estimating the total effort and cost of developing, debugging and maintaining the system.

The NOC metric can also usefully be applied at the package and class level as well as the total system.

NOCL is defined for class and interfaces. It counts the number of classes or interfaces that are declared. This is usually 1, but nested class declarations will increase this number. .bannercell { border: 0px; padding: 0px; } body { margin-left: 10; margin-right: 10; font:normal 80% arial,helvetica,sanserif; background-color:#FFFFFF; color:#000000; } .a td { background: #efefef; } .b td { background: #fff; } th, td { text-align: left; vertical-align: top; } th { font-weight:bold; background: #ccc; color: black; } table, th, td { font-size:100%; border: none } table.log tr td, tr th { } h2 { font-weight:bold; font-size:140%; margin-bottom: 5; } h3 { font-size:100%; font-weight:bold; background: #525D76; color: white; text-decoration: none; padding: 5px; margin-right: 2px; margin-left: 2px; margin-bottom: 0; } .Error { font-weight:bold; color:red; }

Class .

Methods