Nested interface

Question

Can anybody make any sense of this?
I cannot do this:
interface Action {
     void run();
class SomeAction implements Action {
     public void run() { ? }
class Controller<A extends Action> {
     public interface Command {
       void doIt(A action);                                      // compile-time error
       void undoIt(A action);                                    // compile-time error
class SomeController implements Controller<SomeAction>.Command {   // compile-time error
     public void doIt(SomeAction action) { ? }
     public void undoIt(SomeAction action) { ? }
}But I can do that:
interface Action {
     void run();
class SomeAction implements Action {
     public void run() { ? }
class Controller<A extends Action> {
     public interface Command<A extends Action>  {
       void doIt(A action);
             void undoIt(A action);
class SomeController implements Controller.Command<SomeAction> {
       public void doIt(SomeAction action) { ? }
     public void undoIt(SomeAction action) { ? }
}Why?
After type erasure the Controller.Command interface boils down to the same thing either way, namely:
class Controller {
     public interface Command  {
       void doIt(Action action);
             void undoIt(Action action);
}I understand that type variables must not appear in static context of a parameterized class and that the first example is rejected for this reason. But, ... is there a really compelling reason?
It is even worse than in my code snippet. Using the prototype compiler I can refer to the nested interface in the second code sample as
Controller.Command<SomeAction>
Controller<SomeAction>.Command<SomeAction>
Controller<String>.Command<SomeAction>
Where is the point?

Answer 1

>
Looks like a bug to me. Your inner interface in the
first example is not a static context; therefore the
type variable should work there.My understanding is that nested interfaces ARE static (ie the one inner interface is shared by all instances of the enclosing class), and therefore the type variable's scope does NOT include the inner interfaces.
So its not a bug.
if you are not sure why we're all talking about whether the interfaces are static or not, it is because the draft spec says (section 2.2 near bottom of page 3)
The scope of a type parameter is all of the declared class, except any static members or initializers, but
including the type parameter section itself. Therefore, type parameters can appear as parts of their
own bounds, or as bounds of other type parameters declared in the same section.
However, whether the inner interfaces should be included under that broad clause, is debatable. (Well I think it's debatable, and despite bringing the issue up previously, no-one has debated the contrary point in this forum)
The debate could be ended by someone showing how the type system could be broken if an inner interface did reference a type variable of the enclosing class. Any takers?
In the absence of such proof, it would seem convenient if we didn't have to declare the type parameter in both the enclosing class and the inner interface.
In summary, what you observe is consistent with (Sun's understanding of) the draft spec. but I believe the spec itself (or Sun's interpretation), is open to discussion.
Bruce