Java enum with generic attributes

Question

I have been trying to create enum that contains generic attribute, for example:

public enum SomeEnum {
    SOME_VALUE_1(SomeValue1.class),
    SOME_VALUE_2(SomeValue2.class);

    private final Class<T extends SomeValue> className;
}

SomeValue1 and SomeValue2 classes implement SomeValue interface. For some reason <T extends SomeValue> is marked with "Unexpected bound" error. If I replace T with ?, there is no error. But it is still puzzling me why it is happening when I use T.

Any help would be highly appreciated.

rgettman · Accepted Answer · 2020-12-17 01:03:32Z

4

When you use T extends SomeValue in this way, you are referencing a type variable T that isn't defined, and you aren't allowed to define a type variable there. Only on type variable declarations are you allowed to define a bound such as T extends SomeValue.

On an interface or class, you could define T with the bound you want, but not on an enum. Enums are not allowed to be generic in Java.

You are probably getting the same error on the constructor you haven't shown that accepts a Class<T extends SomeValue> to assign to className. The same reason applies here too.

Using ? extends SomeValue is an upper-bounded wildcard. It basically means "a specific yet unknown type that is SomeValue or a subtype". This is appropriate here, because all you care about here is that the Class is for SomeValue or some implementation class.

answered Dec 17, 2020 at 1:03

rgettman

179k30 gold badges282 silver badges365 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Java dude Over a year ago

I am using Lombok, so didn't notice it in constructor, but it makes sense. Thank you very much for the explanation, now it is clear to me.

Sweeper · Accepted Answer · 2020-12-17 01:08:55Z

<? extends SomeClass> and <T extends SomeClass> are two very different syntaxes.

The first is a wildcard bound, part of a type argument:

TypeArguments:
  < TypeArgumentList >
TypeArgumentList:
  TypeArgument {, TypeArgument}
TypeArgument:
  ReferenceType 
  Wildcard
Wildcard:
  {Annotation} ? [WildcardBounds]
WildcardBounds:
  extends ReferenceType 
  super ReferenceType

The second is a type bound, part of a type parameter:

TypeParameter:
  {TypeParameterModifier} Identifier [TypeBound]
TypeParameterModifier:
  Annotation
TypeBound:
  extends TypeVariable 
  extends ClassOrInterfaceType {AdditionalBound}

What's the difference between a type parameter and a type argument? A type parameter, like a method parameter, occurs at e.g. a generic class/method declaration:

class Foo<T extends SomeClass> {} // "T extends SomeClass" is a type parameter
class Bar<T> {} // "T" is a type parameter

This is analogous to method parameters:

void foo(int i) {} // "int i" is a method parameter

A type argument, like a method argument, occurs where you use a generic class/method. For example, in a field declaration:

Foo<? extends SomeClass> foo; // "? extends SomeClass" is a type argument
Bar<String> // "String" is a type argument

This is analogous to method arguments that you pass when you call a method:

foo(1); // "1" is a method argument

So really, using T extends SomeClass where you should use ? extends SomeClass makes no sense. You are not declaring a new type variable here. You are merely constructing a generic type.

Collectives™ on Stack Overflow

Java enum with generic attributes

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related