enum implementation inside interface - Java

Question

I have a question about putting a Java enum in the interface. To make it clearer, please see the following code:

public interface Thing{
   public enum Number{
       one(1), two(2), three(3);
       private int value;
       private Number(int value) {
            this.value = value;
       }
       public int getValue(){
        return value;
       }
   }

   public Number getNumber();
   public void method2();
   ...
}

I know that an interface consists of methods with empty bodies. However, the enum I used here needs a constructor and a method to get an associated value. In this example, the proposed interface will not just consist of methods with empty bodies. Is this implementation allowed?

I am not sure if I should put the enum class inside the interface or the class that implements this interface.

If I put the enum in the class that implements this interface, then the method public Number getNumber() needs to return the type of enum, which would force me to import the enum in the interface.

Answer 1

It's perfectly legal to have an enum declared inside an interface. In your situation the interface is just used as a namespace for the enum and nothing more. The interface is used normally wherever you use it.

Answer 2

Example for the Above Things are listed below :

public interface Currency {

  enum CurrencyType {
    RUPEE,
    DOLLAR,
    POUND
  }

  public void setCurrencyType(Currency.CurrencyType currencyVal);

}


public class Test {

  Currency.CurrencyType currencyTypeVal = null;

  private void doStuff() {
    setCurrencyType(Currency.CurrencyType.RUPEE);
    System.out.println("displaying: " + getCurrencyType().toString());
  }

  public Currency.CurrencyType getCurrencyType() {
    return currencyTypeVal;
  }

  public void setCurrencyType(Currency.CurrencyType currencyTypeValue) {
    currencyTypeVal = currencyTypeValue;
  }

  public static void main(String[] args) {
    Test test = new Test();
    test.doStuff();
  }

}

Answer 3

In short, yes, this is okay.

The interface does not contain any method bodies; instead, it contains what you refer to as "empty bodies" and more commonly known as method signatures.

It does not matter that the enum is inside the interface.

Answer 4

Yes, it is legal. In a "real" situation Number would implement Thing, and Thing would probably have one or more empty methods.