Multiple BoundsBounded type parameters can be used with methods as well as classes and interfaces. Java Generics supports multiple bounds also, i.e., In this case, A can be an interface or class. If A is class, then B and C should be interfaces. We can't have more than one class in multiple bounds.
Bounded Type Parameters There may be times when you'll want to restrict the kinds of types that are allowed to be passed to a type parameter. For example, a method that operates on numbers might only want to accept instances of Number or its subclasses. This is what bounded type parameters are for.
To declare a bounded type parameter, list the type parameter's name, followed by the extends keyword, followed by its upper bound, which in this example is Number .
What is the difference between a wildcard bound and a type parameter bound? A wildcard can have only one bound, while a type parameter can have several bounds. A wildcard can have a lower or an upper bound, while there is no such thing as a lower bound for a type parameter.
I'm also not sure why the restriction is there. You could try sending a friendly e-mail to the designers of Java 5 Generics (chiefly Gilad Bracha and Neal Gafter).
My guess is that they wanted to support only an absolute minimum of intersection types (which is what multiple bounds essentially are), to make the language no more complex than needed. An intersection cannot be used as a type annotation; a programmer can only express an intersection when it appears as the upper bound of a type variable.
And why was this case even supported? The answer is that multiple bounds allow you to control the erasure, which allows to maintain binary compatibility when generifying existing classes. As explained in section 17.4 of the book by Naftalin and Wadler, a max
method would logically have the following signature:
public static <T extends Comparable<? super T>> T max(Collection<? extends T> coll)
However, this erases to:
public static Comparable max(Collection coll)
Which does not match the historical signature of max
, and causes old clients to break.
With multiple bounds, only the left-most bound is considered for the erasure, so if max
is given the following signature:
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
Then the erasure of its signature becomes:
public static Object max(Collection coll)
Which is equal to the signature of max
before Generics.
It seems plausible that the Java designers only cared about this simple case and restricted other (more advanced) uses of intersection types because they were just unsure of the complexity that it might bring. So the reason for this design decision does not need to be a possible safety problem (as the question suggests).
More discussion on intersection types and restrictions of generics in an upcoming OOPSLA paper.
Two possible reasons for outlawing this:
Complexity. JDK-4899305 suggests that a bound containing a type parameter plus additional parameterized types would allow for even more complicated mutually recursive types than already exist. In short, Bruno's answer.
The possibility of specifying illegal types. Specifically, extending a generic interface twice with different parameters. I can't come up with a non-contrived example, but:
/** Contains a Comparator<String> that also implements the given type T. */ class StringComparatorHolder<T, C extends T & Comparator<String>> { private final C comparator; // ... } void foo(StringComparatorHolder<Comparator<Integer>, ?> holder) { ... }
Now holder.comparator
is a Comparator<Integer>
and a Comparator<String>
. It's not clear to me exactly how much trouble this would cause for the compiler, but it's clearly not good. Suppose in particular that Comparator
had a method like this:
void sort(List<? extends T> list);
Our Comparator<Integer>
/ Comparator<String>
hybrid now has two methods with the same erasure:
void sort(List<? extends Integer> list); void sort(List<? extends String> list);
It's for these kinds of reasons that you can't specify such a type directly:
<T extends Comparator<Integer> & Comparator<String>> void bar() { ... }
java.util.Comparator cannot be inherited with different arguments: <java.lang.Integer> and <java.lang.String>
Since <A extends I & Adapter<E>>
allows you to do the same thing indirectly, it's out, too.
Here's another quote from JLS:
The form of a bound is restricted (only the first element may be a class or type variable, and only one type variable may appear in the bound) to preclude certain awkward situations coming into existence.
What exactly are those awkward situations, I don't know.
This probably does not answer the root question, but just want to point out that the spec unambiguously forbids it. Google search for the error message took me to this blog entry, which further points to jls 4.4:
The bound consists of either a type variable, or a class or interface type T possibly followed by further interface types I1 , ..., In.
So, if you use type parameter as bound you cannot use any other bound, just as the error message says.
Why the restriction? I have no idea.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With