Why different class files are created for each enum type if they have constant-specific method?

Question

i have one enum as

enum OperationsType {
  ADD("+"), SUB("-"), DIV("/"), MUL("*");

  private String opcodes;

  private OperationsType(String opcodes) {
    this.opcodes = opcodes;
  }

  public String toString() {
    return this.opcodes;
  }
}

Here all enum type doesn't have any constant Specific method so javac is creating only one class file for enum as

OperationsType.class

but if i add constant Specific method in same code for all enum type then javac is creating 5 class files.

Operations.class
Operations$1.class
Operations$2.class
Operations$3.class
Operations$4.class

for below code

enum Operations {
ADD("+") {
    public double apply(double a, double b) {
        return a + b;
    }
},
SUB("-") {
    public double apply(double a, double b) {
        return a - b;
    }
},
DIV("/") {
    public double apply(double a, double b) {
        return a / b;
    }
},
MUL("*") {
    public double apply(double a, double b) {
        return a * b;
    }
};

private String opcodes;

private Operations(String opcodes) {
    this.opcodes = opcodes;
}

public abstract double apply(double a, double b);
}

So i have doubt that why compiler has created 4 different classes for each enum type if they are having constant Specific method but not creating different classes if they don't have constant Specific method?

Answer 1

Enums with constant-specific methods are implemented using anonymous inner classes. As mentioned in The Java Language Specification:

The optional class body of an enum constant implicitly defines an anonymous class declaration (§15.9.5) that extends the immediately enclosing enum type. The class body is governed by the usual rules of anonymous classes; in particular it cannot contain any constructors.

Anonymous inner classes are implemented by creating class files with names like OuterClass$1, OuterClass$2 etc., and this is exactly what happens in the case of the enum.

Answer 2

Consider the following class:

public class Test {
    public double testApply(Operations operation, double a, double b) {
        return operation.apply(a, b);
    }

    public static void main(String[] args) {
        Test test = new Test();
        assert 3.0 == test.testApply(OperationsType.ADD, 2.0, 1.0);
        assert 1.0 == test.testApply(OperationsType.SUB, 2.0, 1.0);
    }
}

In the body of method testApply the compilier doesn't know the exact type of the argument operation (is it ADD or SUB?), it only knows that it is an instance of type Operations. In order to dispatch the invocation of apply correctly, the VM needs to know the runtime type of the argument. However if you only have one class for all values that would be impossible. Therefore the compiler creates different classes for each value and dispatches the invocation according to the run-time type.

On the other hand, if you do not define any constant specific methods then there is no need to create subclasses, since there are no operations that must be dispatched depending on the runtime type of the receiver object. Hence the compiler simply omits the generation of these classes.