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