如果其中一个边界是类，则必须首先在java泛型中指定它。 为什么？

Question

I was referring to this java docs . If one of the bounds is a class, it must be specified first . What I feel is it should allow in any order.

Why do java has such restriction ? Is there any specific reason behind this?

Multiple Bounds

The preceding example illustrates the use of a type parameter with a single bound, but a type parameter can have multiple bounds:

A type variable with multiple bounds is a subtype of all the types listed in the bound. If one of the bounds is a class, it must be specified first. For example:

Class A { /* ... */ } 
interface B { /* ... */ }
interface C { /* ...
 */ }

class D <T extends A & B & C> { /* ... */ }

If bound A is not specified first, you get a compile-time error:

 class D <T extends B & A & C> { /* ... */ }  // compile-time error ,but why ?

Answer 1

First off, there can only be a single class there; each Java class (except java.lang.Object , which is a special case as the root of the hierarchy) can only ever inherit from a single other class. There can be multiple interfaces, but at most one class. This enormously simplifies the processing of the type hierarchy and the object construction process.

Given that, the language designers decided that the class has to be listed first in the bounds (if it is present at all). There's actually no deep reason for that — the compiler could have coped just fine with enforcing the only-one-class restriction without the ordering — but it does make things somewhat easier to teach as there's a simple rule: if you're using a class as a generic type bound, put it first .

Answer 2

Might be they just to group the interfaces together, separate from the class.

If T was a class then it would look as following:

public class T extends A implements B, C {

But in generics there is no implements , and only extends . So, the constraint could be only to make us list the class itself first and then list the interfaces due to the lack of the key word implements .

Answer 3

JLS # 4.4. Type Variables

Every type variable declared as a type parameter has a bound. If no bound is declared for a type variable, Object is assumed. If a bound is declared, it consists of either:

• a single type variable T , or
• a class or interface type T possibly followed by interface types I1 & ... & In

Answer 4

I would say as "A type variable with multiple bounds is a subtype of all the types listed in the bound." and it seems Java asks you to indicate the extends First in a class declaration that would be the reason. (On the other hand a class can only extend one other class)