Trying to use valueOf with a generic enum class

I'm making a class that takes in an enum class in it's constructor, the thing is that I want it to be able to take in any enum so I'm using the following generic definition: <T extends Enum<T>>.

My question is why can't I use enumClass.valueof(string)? (I get the following error: The method valueOf(String) is undefined for the type Class<T>). I've found that using Enum.valueOf(enumClass, string) works but I don't understand why, any help is appreciated.

public class ValidadorEntradaEnum<T extends Enum<T>> {
    private final Class<T> enumClass;

    public ValidadorEntradaEnum(Class<T> enumClass) {
        this.enumClass = enumClass;
    }

    public boolean containsString(String string) {
        try {
            Enum.valueOf(enumClass, string);
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }
}

My question is why can't I use enumClass.valueof(string)?

In your example, enumClass is of type Class<T extends Enum<T>>. So, if we look at the documentation for java.lang.Class and do a Ctrl+F for valueOf, we see that there is no such method called valueOf.

However, if we go to the documentation for java.lang.Enum, we see that there is a valueOf method, which takes in 2 parameters -- a Class with a type parameter of <T extends Enum<T>> and a String.

Let's say that I have an enum called SomeEnum.

enum SomeEnum
{

    SOME_ENUM_VALUE,
    ;

}

When I press compile, java takes this enum definition and turns it into a class with a couple of special methods. One of those methods is the valueOf method which takes in a String. This is the one you seem to want.

Let's say that I have a String that I want to convert into SomeEnum.

final String someString = "SOME_ENUM_VALUE";

So then your question is, why can't I do enumClass.valueOf(someString)?

The problem is, enumClass is a Class<T extends Enum<T>>, not an enum. You probably did something like this to get enumClass populated.

final Class<T extends Enum<T>> enumClass = SomeEnum.class;

But remember, java.lang.Class does not have the valueOf method! The only ones that have valueOf is java.lang.Enum and this SomeEnum that I made!

I think I see the reason why you are confused.

Some people see this...

SomeEnum.valueOf(someString)

...and think that it is equivalent to typing this...

SomeEnum.class.valueOf(someString)

...which is incorrect.

SomeEnum represents your enum's class and gives up the static methods, fields, and values.

SomeEnum.class represents your enum's CLASS FILE! It's job is to DESCRIBE your enum's capabilities, but it cannot USE any of the capabilities of your enum!

Because if so, then you could do this.

SomeEnum.class.valueOf(someString) //WRONG, not possible

SomeEnum.valueOf(someString) just means "call the static method valueOf on SomeEnum for the parameter someString"

Now, if your next question is, how do I get the static method valueOf when I only have a java.lang.Class? Well, the easiest way is to use Enum.valueOf(someClass, someString), just like you already found. That's literally the reason why they created that method. They knew that someone like you would come around asking how to turn a String into an enum when you only have the Class of the enum. So, they made that method.

The one-argument valueOf() method and the values() method are static methods that are defined on each enum type, as specified in the "Enum Members" section of the Java Language Specification.

They are not "inherited" from the Enum class or any other class, since static methods cannot be overridden in Java. So you will not see these methods in the Java standard library documentation. Unlike with instance methods, which class a static method is called on is fixed at compile time. To call a static method, you would either 1) explicitly specify the name of a class, like <name of class>.<static method name>(), 2) call it without explicitly qualifying it, like <static method name>(), or 3) call it on an expression, like <some expression>.<static method name>(). If you use the #1, it will call the method of the named class. If you use #2, it will call the method of the class the code is in. If you use #3, it will use the compile-time type of the expression as the class to use. Counterintuitively, it will not use the runtime value of the expression. So even if the runtime value of the expression was a reference to a subclass which has a static method of the same name, or the runtime value of the expression was null, it will still call the static method on the compile-time type.

The Enum class does not define the values() or one-argument valueOf() static methods. Even if it did, these methods would be useless -- you would not be able to use them to call the values() or one-argument valueOf() static methods of an enum type, because the class that a static method is called on is determined at compile time. There is no way in Java to call a static method on a class that is determined dynamically at runtime, except using reflection. You cannot just call the static method on the Class instance representing your enum type, because static methods are not methods on the Class instance -- only the methods documented as methods of the Class class can be called on Class instances.

So if you wanted, you could call the one-argument valueOf() method on your class via reflection, and it would work:

Method m = enumClass.getMethod("valueOf", String.class);
T value = (T) m.invoke(null, string);

The authors of the Java standard library decided to provide a convenience API to accomplish this without reflection, by providing the two-argument Enum.valueOf() method, as you have discovered: T value = Enum.valueOf(enumClass, string). This two-argument Enum.valueOf() method is completely unrelated to the one-argument valueOf() method of enum types, other than having the same name. It is not some magical syntax that allows you to call a static method on a dynamically-determined class by calling it with two arguments -- it is just simply a separate API provided for this one use case.

(As an aside, the same thing is true for the values() static method of enum types. There is no way to call it on a class dynamically determined at runtime, except using reflection. You can achieve it using reflection, and it works:

Method m = enumClass.getMethod("values");
T[] values = (T[]) m.invoke(null);

However, they also provided a convenience API to achieve this without reflection -- the getEnumConstants() method on the Class class representing the enum type: T[] values = enumClass.getEnumConstants().)

You can use Class.getEnumConstants to get the enum values of an enum from its class object. Each enum value has a value which you can then use to determine if your enum contains the string you're checking.