Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

• Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
• Code is considered more complex for each "break in the linear flow of the code"
• Code is considered more complex when "flow breaking structures are nested"

Further reading

• Cognitive Complexity docs
• Cognitive Complexity: A new way of measuring understandability

LongVariable

Since: PMD 0.3

Priority: Medium

Categories: Style

Remediation Points: 50000

Fields, formal arguments, or local variable names that are too long can make the code difficult to follow.

Example:

public class Something {
 int reallyLongIntName = -3; // VIOLATION - Field
 public static void main( String argumentsList[] ) { // VIOLATION - Formal
 int otherReallyLongName = -5; // VIOLATION - Local
 for (int interestingIntIndex = 0; // VIOLATION - For
 interestingIntIndex < 10;
 interestingIntIndex ++ ) {
 }
}

UncommentedEmptyConstructor

Since: PMD 3.4

Priority: Medium

Categories: Style

Remediation Points: 50000

Uncommented Empty Constructor finds instances where a constructor does not contain statements, but there is no comment. By explicitly commenting empty constructors it is easier to distinguish between intentional (commented) and unintentional empty constructors.

Example:

public Foo() {
 // This constructor is intentionally empty. Nothing special is needed here.
}

SimpleDateFormatNeedsLocale

Since: PMD 2.0

Priority: Medium

Categories: Style

Remediation Points: 50000

Be sure to specify a Locale when creating SimpleDateFormat instances to ensure that locale-appropriate formatting is used.

Example:

public class Foo {
 // Should specify Locale.US (or whatever)
 private SimpleDateFormat sdf = new SimpleDateFormat('pattern');
}

UseStringBufferForStringAppends

Since: PMD 3.1

Priority: Medium

Categories: Style

Remediation Points: 50000

The use of the '+=' operator for appending strings causes the JVM to create and use an internal StringBuffer. If a non-trivial number of these concatenations are being used then the explicit use of a StringBuilder or threadsafe StringBuffer is recommended to avoid this.

Example:

public class Foo {
 void bar() {
 String a;
 a = 'foo';
 a += ' bar';
 // better would be:
 // StringBuilder a = new StringBuilder('foo');
 // a.append(' bar');
 }
}

ImmutableField

Since: PMD 2.0

Priority: Medium

Categories: Style

Remediation Points: 50000

Identifies private fields whose values never change once they are initialized either in the declaration of the field or by a constructor. This helps in converting existing classes to becoming immutable ones.

Example:

public class Foo {
 private int x; // could be final
 public Foo() {
 x = 7;
 }
 public void foo() {
 int a = x + 2;
 }
}

LongVariable

Since: PMD 0.3

Priority: Medium

Categories: Style

Remediation Points: 50000

Fields, formal arguments, or local variable names that are too long can make the code difficult to follow.

Example:

public class Something {
 int reallyLongIntName = -3; // VIOLATION - Field
 public static void main( String argumentsList[] ) { // VIOLATION - Formal
 int otherReallyLongName = -5; // VIOLATION - Local
 for (int interestingIntIndex = 0; // VIOLATION - For
 interestingIntIndex < 10;
 interestingIntIndex ++ ) {
 }
}

UseStringBufferForStringAppends

Since: PMD 3.1

Priority: Medium

Categories: Style

Remediation Points: 50000

The use of the '+=' operator for appending strings causes the JVM to create and use an internal StringBuffer. If a non-trivial number of these concatenations are being used then the explicit use of a StringBuilder or threadsafe StringBuffer is recommended to avoid this.

Example:

public class Foo {
 void bar() {
 String a;
 a = 'foo';
 a += ' bar';
 // better would be:
 // StringBuilder a = new StringBuilder('foo');
 // a.append(' bar');
 }
}

UseStringBufferForStringAppends

Since: PMD 3.1

Priority: Medium

Categories: Style

Remediation Points: 50000

The use of the '+=' operator for appending strings causes the JVM to create and use an internal StringBuffer. If a non-trivial number of these concatenations are being used then the explicit use of a StringBuilder or threadsafe StringBuffer is recommended to avoid this.

Example:

public class Foo {
 void bar() {
 String a;
 a = 'foo';
 a += ' bar';
 // better would be:
 // StringBuilder a = new StringBuilder('foo');
 // a.append(' bar');
 }
}

ImmutableField

Since: PMD 2.0

Priority: Medium

Categories: Style

Remediation Points: 50000

Identifies private fields whose values never change once they are initialized either in the declaration of the field or by a constructor. This helps in converting existing classes to becoming immutable ones.

Example:

public class Foo {
 private int x; // could be final
 public Foo() {
 x = 7;
 }
 public void foo() {
 int a = x + 2;
 }
}

AvoidReassigningParameters

Since: PMD 1.0

Priority: Medium High

Categories: Style

Remediation Points: 50000

Reassigning values to incoming parameters is not recommended. Use temporary local variables instead.

Example:

public class Foo {
 private void foo(String bar) {
 bar = 'something else';
 }
}

LongVariable

Since: PMD 0.3

Priority: Medium

Categories: Style

Remediation Points: 50000

Fields, formal arguments, or local variable names that are too long can make the code difficult to follow.

Example:

public class Something {
 int reallyLongIntName = -3; // VIOLATION - Field
 public static void main( String argumentsList[] ) { // VIOLATION - Formal
 int otherReallyLongName = -5; // VIOLATION - Local
 for (int interestingIntIndex = 0; // VIOLATION - For
 interestingIntIndex < 10;
 interestingIntIndex ++ ) {
 }
}

SimpleDateFormatNeedsLocale

Since: PMD 2.0

Priority: Medium

Categories: Style

Remediation Points: 50000

Be sure to specify a Locale when creating SimpleDateFormat instances to ensure that locale-appropriate formatting is used.

Example:

public class Foo {
 // Should specify Locale.US (or whatever)
 private SimpleDateFormat sdf = new SimpleDateFormat('pattern');
}

SimpleDateFormatNeedsLocale

Since: PMD 2.0

Priority: Medium

Categories: Style

Remediation Points: 50000

Be sure to specify a Locale when creating SimpleDateFormat instances to ensure that locale-appropriate formatting is used.

Example:

public class Foo {
 // Should specify Locale.US (or whatever)
 private SimpleDateFormat sdf = new SimpleDateFormat('pattern');
}

UseStringBufferForStringAppends

Since: PMD 3.1

Priority: Medium

Categories: Style

Remediation Points: 50000

The use of the '+=' operator for appending strings causes the JVM to create and use an internal StringBuffer. If a non-trivial number of these concatenations are being used then the explicit use of a StringBuilder or threadsafe StringBuffer is recommended to avoid this.

Example:

public class Foo {
 void bar() {
 String a;
 a = 'foo';
 a += ' bar';
 // better would be:
 // StringBuilder a = new StringBuilder('foo');
 // a.append(' bar');
 }
}

AbstractNaming

Since: PMD 1.4

Priority: Medium

Categories: Style

Remediation Points: 50000

Abstract classes should be named 'AbstractXXX'.

Example:

public abstract class Foo { // should be AbstractFoo
}

LongVariable

Since: PMD 0.3

Priority: Medium

Categories: Style

Remediation Points: 50000

Fields, formal arguments, or local variable names that are too long can make the code difficult to follow.

Example:

public class Something {
 int reallyLongIntName = -3; // VIOLATION - Field
 public static void main( String argumentsList[] ) { // VIOLATION - Formal
 int otherReallyLongName = -5; // VIOLATION - Local
 for (int interestingIntIndex = 0; // VIOLATION - For
 interestingIntIndex < 10;
 interestingIntIndex ++ ) {
 }
}

UseStringBufferForStringAppends

Since: PMD 3.1

Priority: Medium

Categories: Style

Remediation Points: 50000

The use of the '+=' operator for appending strings causes the JVM to create and use an internal StringBuffer. If a non-trivial number of these concatenations are being used then the explicit use of a StringBuilder or threadsafe StringBuffer is recommended to avoid this.

Example:

public class Foo {
 void bar() {
 String a;
 a = 'foo';
 a += ' bar';
 // better would be:
 // StringBuilder a = new StringBuilder('foo');
 // a.append(' bar');
 }
}

AvoidInstantiatingObjectsInLoops

Since: PMD 2.2

Priority: Medium

Categories: Style

Remediation Points: 50000

New objects created within loops should be checked to see if they can created outside them and reused.

Example:

public class Something {
 public static void main( String as[] ) {
 for (int i = 0; i < 10; i++) {
 Foo f = new Foo(); // Avoid this whenever you can it's really expensive
 }
 }
}

ImmutableField

Since: PMD 2.0

Priority: Medium

Categories: Style

Remediation Points: 50000

Identifies private fields whose values never change once they are initialized either in the declaration of the field or by a constructor. This helps in converting existing classes to becoming immutable ones.

Example:

public class Foo {
 private int x; // could be final
 public Foo() {
 x = 7;
 }
 public void foo() {
 int a = x + 2;
 }
}