Java enum overkill?

Question

I have often the situation where I need a variable for a class that could be represented as simple enum type, for example:

private enum PageOrder {DOWN_THEN_OVER, OVER_THEN_DOWN};

If a declare the enum type within the class that holds the variable then I have to use the qualified name MyClass.PageOrder which is not comfortable. But if I create a new class I have a class for just a simple enum declaration, which seems overkill for me.

For that reason, I frequently use integers instead of enum type.

Any comments/suggestions on this topic?

Never "fix" the correct solution to an incorrect one just to save typing. — biziclop, Sep 24 '14 at 09:52
"*But if I create a new class I have a class for just a simple enum declaration, which seems overkill for me*" - where is the overkill? A private enum is a class as well (with its own .class file) - it only has a different visibility. — , Sep 24 '14 at 11:37
An enum in its own file may seem like overkill, but it's not. It's completely appropriate and it's good design. Add some useful javadoc to the enum class and to each of its constants, and you'll find that the source file won't look nearly as sparse. There are legitimate uses for inner classes, but making something an inner class merely because its own file would be "too heavyweight" is not a good reason. — VGR, Sep 24 '14 at 13:56
Android uses integer constants all over instead of enums. I've read somewhere that enums were originally way way slower, and that's why they implemented this policy, though by now the performance caught up. — marczellm, Sep 24 '14 at 19:29

score 34 · Accepted Answer · edited May 23 '17 at 12:16

34

You can do

import static yourpkg.MyClass.PageOrder;

This will always work since inner enums are always static. Note that this works even in the file that defines the MyClass class.

edited May 23 '17 at 12:16

Community

1
1

answered Sep 24 '14 at 09:50

aioobe

413,195
112
811
826

4

And you can configure Eclipse to automatically insert static imports. – biziclop Sep 24 '14 at 09:53
2

Yup. As explained [here](http://stackoverflow.com/questions/288861/eclipse-optimize-imports-to-include-static-imports). – aioobe Sep 24 '14 at 09:54
1

Enums avoid ambiguity or just plain cryptic code. `renderPage(1)` isn't as informative as `renderPage(OVER_THEN_DOWN)`. – sfdcfox Sep 24 '14 at 15:09
Enums make your code type-safe. When using integers you could easily pass an invalid value - when you use enums, you can only pass valid values (enum constants). – Jesper Sep 24 '14 at 17:00

OldCurmudgeon · Answer 2 · 2014-09-24T13:44:52.250

21

For that reason, I frequently use integers instead of enum type.

Please don't do that.

You can often choose a name for the parent class and the enum that actually helps the clarity of the code.

class Page {
    enum Order {
        DOWN_THEN_OVER, OVER_THEN_DOWN;
    }
}

// Accessing: A little verbose but clear and efficient.
Page.Order order = Page.Order.DOWN_THEN_OVER;

You can also static import each enum you use but I prefer the verbosity above.

import static com.oldcurmudgeon.test.Test.Order.DOWN_THEN_OVER;
import static com.oldcurmudgeon.test.Test.Order.OVER_THEN_DOWN;

public class Test {

    enum Order {

        DOWN_THEN_OVER, OVER_THEN_DOWN;
    }

    public void test() {
        Order pageOrder = DOWN_THEN_OVER;
    }

}

Obviously you cannot take this approach if the enum is private.

edited Sep 24 '14 at 13:44

answered Sep 24 '14 at 10:23

OldCurmudgeon

64,482
16
119
213

1

The alternative to enum is to use `public static final int DOWN_THEN_OVER = 0; public static final int OVER_THEN_DOWN = 1;` and it seems to me that both are equally readable and maintainable for small set of values. – John Henckel Sep 24 '14 at 21:25
int DOWN_THEN_OVER = 1; int OVER_THEN_DOWN = 1;int wackyDuck = 1; /* DOWN_THAN_OVER stored as int could be the same as OVER_THAN_DOWN or just a wacky duck*/ – Shivan Dragon Sep 24 '14 at 21:57
2

@JohnHenkel - `public static final int DOWN_THEN_OVER = 0; public static final int OVER_THEN_DOWN = 1;... public static final int UP_THEN_AT_THEM = 92367;` - `turnPage(UP_THEN_AT_THEM)` - do you see the danger now? With an `enum` you just cannot do that - even by mistake. – OldCurmudgeon Sep 24 '14 at 22:03
Why "please don't do that" to using `int`s vs `enum`s? It seems reasonable... Even the JAVA API does these (for example, `KeyEvent.VK_stuff`, JFrame's `EXIT_ON_CLOSE`, etc). – YoTengoUnLCD Jun 13 '16 at 03:08

score -2 · Answer 3 · answered Sep 24 '14 at 22:26

If you are using enums just to give coder friendly names to numbers, and you never have to write them to screen, or read them from a file, then it's totally an overkill. Unfortunate artifact of the fact that everything in java has to be a class. If that's how you are using the enums, I recommend using constants instead.

If you want to print the value of the enum in user friendly format, or to convert a value to an enum, than you probably do need the class.

Java enum overkill?

3 Answers3