Contents - Cultural View

Constant interface 100
Constant interface
In the Java programming language, the constant interface pattern describes the use of an interface solely to define
constants, and having classes implement that interface in order to achieve convenient syntactic access to those
constants. However, since the usage of constants is an implementation detail, it is considered inappropriate to define
an interface for this purpose. [1] [2] In general, collecting system constants into classes independent of behaviour,
might create a poor object-oriented design, because it is often a sign of low cohesion. It is for these reasons that
implementing constants interfaces is considered to be an anti-pattern.
Use of this anti-pattern has a few other downsides:
1. It pollutes the class namespace with read-only variables that may not be of use.
2. Contrary to the compile-time tactical utility of implementing a constants interface, the incidental run-time
artifacts have little practical purpose (cf. marker interfaces which also have no methods but are useful at
run-time).
3. If binary code compatibility is required in future releases, the constants interface must remain forever an interface
(it cannot be converted into a class), even though it has not been used as an interface in the conventional sense.
4. Without an IDE that resolves where the constant are coming from, tracking it back to its containing class or
interface can be time consuming.
5. A variable (representing an instance) of the interface is syntactically no more useful than the interface name itself
(since it has no methods).
Example
public interface Constants {
}
public static final double PI = 3.14159;
public static final double PLANCK_CONSTANT = 6.62606896e-34;
public class Calculations implements Constants {
}
public double getReducedPlanckConstant() {
}
Alternatives
return PLANCK_CONSTANT / (2 * PI);
Many of the pitfalls of the anti-pattern can be avoided by converting the constants interface to a proper class with no
instances:
public final class Constants {
private Constants() {
}
// restrict instantiation
public static final double PI = 3.14159;