Is using an object instantiation as an enum entry's value good practice?

Question

First off, apologies if this is a duplicate of an existing question. Wasn't precisely sure how to word my question so that may be why I haven't found a clear answer yet. Essentially, I want to know if the following is considered good practice or if there is a better way to do this:

public enum ExampleEnum {
    ENTRY_1(new ExampleCodedValue("entry1", "comment1")),
    ENTRY_2(new ExampleCodedValue("entry2", "comment2")),
    ENTRY_3(new ExampleCodedValue("entry3", "comment3")),
    ENTRY_4(new ExampleCodedValue("entry4", "comment4"));

    private ExampleCodedValue codedValue;

    ExampleEnum(ExampleCodedValue codedValue) {
        this.codedValue = codedValue;
    }

    public ExampleCodedValue getCodedValue() {
        return codedValue;
    }
}

class ExampleCodedValue {

    private final String code;
    private final String comment;

    ExampleCodedValue(String code, String comment) {
        this.code = code;
        this.comment = comment;
    }
}

Answer 1

That's a perfectly reasonable way to do it, however, couldn't you do this:

public enum ExampleEnum {
    ENTRY_1("entry1", "comment1");

    private final String entry;
    private final String comment;

    private ExampleEnum(String entry, String comment) {
        ...
    }
}

Answer 2

It's fine, since your ExampleCodedValue is immutable.

However, if it is just a value container, ask yourself if there is a good reason not to put the fields directly into the enum. A good reason might be that your value object is conceptually separate of other fields of the enums.

Another use case for objects contained in enums is to use polymorphism to give each of them different functionality. For example:

PAINT_BRUSH(new PaintTool()),
ERASER(new EraserTool());

With different implementations of execute() or so in PaintTool and EraserTool.

At this point, you might ask yourself though, am I still using the enum to make a choice somewhere, or could I omit the enum altogether and just use the Tool instances directly... Also, traditionally, enumerations don't revolve around functionality.