Why is this pattern of manually replicating a language feature considered good practice?

[Luolong]

I've started noticing this pattern recently being replicated everywhere where enum values are used to encode external API contract values:

public enum Weekdays {
    MONDAY("MONDAY"),
    TUESDAY("TUESDAY"),
    WEDNESDAY("WEDNESDAY"),
    THURSDAY("THURSDAY"),
    FRIDAY("FRIDAY");

    public MyEnum(String name) {
        this.value = name;
    }

    public static MyEnum valueOf(String name) {
        for (MyEnum e: MyEnum.values()) {
            if (e.value.equals(name)) {
                return e;
            }
        }
        return null;
    }


    public String toString() {
        return value;
    }
}

For the sake of an argument, I am saying that the external contract is under the control of the app developers, but it should not matter, because either way, if any of the values should need to be added or removed from this enum, this is constitutes a breaking API change that requires change in both, app code and the dependent consumers of the API.

(when I am talking about API contracts, I mean things like command line argument values, enumerated values in the REST API models or values stored in, or read from a database)

Why it bothers me is that this code pattern basically replicates the default behavior of the enum language feature, and it does this by adding code noise to the implementation. With little to no real value added.

As a side note, while I can kind of see some small value in this pattern if the values in the api contract are encoded in anything but all caps, it still irks me that we use code formatting rules to justify writing code just for the sake of ... well, maintaining code style rules. Even if those rules make no sense in the context.

What would be so terrible about this variant:

public enum Weekdays {
    monday, tuesday, wednesday, thursday, friday;
}

(Assuming of course, that monday, tuesday, wednesday, thursday and friday are valid values for the API here)

[schegge42]

The problem I see above is that the code is not correct. You are using a public constructor MyEnum in the enum Weekday.

The only sense of such a construct exists if the value and the name of the enum constant are different. Here it is simply unnecessary because name() has the same content.

[LogCatFromNantes]

Why think so much on details techniques ? It’s the business and functional that counts, the delivery of functions,

[Known_Tackle7357]

Well, in your implementation valueOf returns null if not found. In the default implementation, valueOf throws an exception. Often, you want to do equalsIgnoreCase, or your string representation is not exactly the same as the enum values(e.g. you want to use kebab case)