Page History

Java supports the use of various types of literals, such as integers (5, 2), floating point numbers (2.5, 6.022e+23), characters ('a', '\n'), Booleans (true, false), and strings ("Hello\n"). Extensive use of literals within a program can lead to two problems: first, the meaning of the literal is often obscured or unclear from the context (magic numbers); second, changing a frequently-used literal requires both searching the entire program source for occurrences of that literal, and also distinguishing the uses those that must be modified from those that should remain unmodified.

Avoid these problems by declaring class variables with meaningfully - named constants as class variables, setting their values to the desired literals, and referencing the constants in place of the literals throughout the program. This approach allows naming that clearly indicates the meaning or intended use of the literal. Further, should the constant require modification, the change is limited to the declaration; searching the code is unnecessary.

...

Although final can be used to specify immutable constants, there is a caveat when dealing with composite objects. See guideline OBJ01-J. Do not assume that declaring a reference to be final reference makes causes the referenced object immutable for more details.

3.1 Noncompliant Code Example

This noncompliant code example calculates approximate dimensions of a sphere, given its radius.

...

The methods use the seemingly-random literals 12.56, 4.19, and 6.28 to represent various scaling factors used to calculate these dimensions. A developer or maintainer reading this code would have little idea about how they were generated or what they mean, and consequently, would be unable to understand the function of this code.

3.2 Noncompliant Code Example

This noncompliant code example attempts to avoid the above issues by explicitly calculating the required constants.

...

The code uses the literal 3.14 to represent the value ?. Although this removes some of the ambiguity from the literals, it complicates code maintenance. If the programmer were to decide that a more precise value of ? is desired, all occurrences of 3.14 in the code would have to be found and replaced.

3.3 Compliant Solution (Constants)

In this compliant solution, a constant PI is declared and initialized to 3.14. Thereafter, it is referenced in the code whenever the value of ? is needed.

...

This reduces clutter and promotes maintainability. If a more precise approximation of the value of ? is required, the programmer can simply redefine the constant.

3.4 Compliant Solution (Predefined Constants)

The class java.lang.Math defines a large group of numeric constants, including PI and the exponential constant E. Prefer the use of Use predefined constants when they are available.

double area(double radius) {
  return 4.0 * Math.PI * radius * radius;
}

double volume(double radius) {
  return 4.0/3.0 * Math.PI * radius * radius * radius;
}

double greatCircleCircumference(double radius) {
  return 2 * Math.PI * radius;
}

3.5 Noncompliant Code Example

This noncompliant code example defines a constant BUFSIZE, but then defeats the purpose of defining BUFSIZE as a constant by assuming a specific value for BUFSIZE in the following expression:

...

The programmer has assumed that it is obvious that BUFSIZE is 512, and right-shifting 9 bits is the same (for positive numbers) as dividing by 512. However, if BUFSIZE changes to 1024 in the future, modifications will be both difficult and error-prone.

3.6 Compliant Solution

This compliant solution uses the identifier assigned to the constant value in the expression.

nblocks = 1 + (nbytes - 1) / BUFSIZE;

3.7 Exceptions

DCL02-EX1: The use of symbolic constants should be restricted to cases where they improve the readability and maintainability of the code. When the intent of the literal is obvious, or where the literal is not likely to change, use of using symbolic constants can impair code readability. The following noncompliant code example obscures the meaning of the code by using too many symbolic constants.

...

The values 4.0 and 3.0 in the volume calculation are clearly scaling factors used to calculate the sphere's volume and are not subject to change (unlike the approximate value for ? ), so they can be represented exactly; there . There is no reason to change them to increase precision . Therefore, because replacing them with symbolic constants actually impairs the readability of the code.

3.8 Risk Assessment

Using numeric literals makes code more difficult to read, understand, and edit.

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this guideline on the CERT website.

3.9 Related Guidelines

C++ Secure Coding Standard: DCL06-CPP. Use meaningful symbolic constants to represent literal values in program logic

C Secure Coding Standard: DCL06-C. Use meaningful symbolic constants to represent literal values

3.10 Bibliography

\[[API 2006|AA. Bibliography#API 06]\]
\[[Core Java 2004|AA. Bibliography#Core Java 04]\]

...