This rule raises an issue when an interface consists only of constant definitions without other members.

## Why is this an issue?

An interface that consists solely of constant definitions is a bad practice. The purpose of interfaces is to provide an API, not implementation details. That is, they should provide functions in the first place and constants only to assist these functions, for example, as possible arguments.

If an interface contains constants only, move them either to somewhere else, or replace the interface with an Enum or a final class with a private constructor.

## How to fix it

If the concrete value of the constants is not essential, and they serve as mere identifiers, replace the interface with an `enum` like in the following example:

    public interface Status { // Noncompliant, enum should be used
      int OPEN = 1;
      int CLOSED = 2;
    }

    public enum Status {      // Compliant
      OPEN,
      CLOSED
    }

In some cases, enums are not a suitable option because the concrete constant value is important. Then you should check whether it is appropriate to move them to a specific existing class, for example, if that class is the primary user of the constants:

    interface AuxiliaryConstants { // Noncompliant, implementation detail of WordPacker
      int BITS_PER_WORD = 16;
      int WORD_MASK = (1 << BITS_PER_WORD) - 1;
      int HI_WORD_BK_MASK = ~(WORD_MASK << BITS_PER_WORD);
    }

    class WordPacker {
      public static int getHiWord(int value) {
        return (value >>> AuxiliaryConstants.BITS_PER_WORD);
      }

      public static int setHiWord(int value, int wordValue) {
        return (value & AuxiliaryConstants.HI_WORD_BK_MASK) |
          (wordValue << AuxiliaryConstants.BITS_PER_WORD);
      }
    }

    class WordPacker { // Compliant
      private static final int BITS_PER_WORD = 16;
      private static final int WORD_MASK = (1 << BITS_PER_WORD) - 1;
      private static final int HI_WORD_BK_MASK = ~(WORD_MASK << BITS_PER_WORD);

      public static int getHiWord(int value) {
          return (value >>> BITS_PER_WORD);
      }

      public static int setHiWord(int value, int wordValue) {
        return (value & HI_WORD_BK_MASK) | (wordValue << BITS_PER_WORD);
      }
    }

If this is not the case and several classes are using the constants equally, you should use a final class with a private constructor. Unlike interfaces, they can neither be inherited from nor instantiated.

    public interface ColorTheme { // Noncomplient, final class should be used
      int COLOR_ERROR = 0xff0000;   // red
      int COLOR_WARNING = 0xffff00; // yellow
      int COLOR_OK = 0x00cf00;      // green
    }

    public final class ColorTheme { // Compliant
      public static final int COLOR_ERROR = 0xff0000;   // red
      public static final int COLOR_WARNING = 0xffff00; // yellow
      public static final int COLOR_OK = 0x00cf00;      // green

      private ColorTheme() {}
    }

## Resources

### Articles & blog posts

- Mohammad Nadeem - Why the Constant Interface Pattern Should Be Discouraged
- Joshua Bloch - Effective Java, ISBN 9780134686097