What does innermost mean?

[Marlene Miller]

What does innermost mean?
JLS 15.12.1 Compile-Time Step 1: Determine Class or Interface to Search

If it is a simple name, that is, just an Identifier, then the name of the method is the Identifier. If the Identifier appears within the scope (�6.3) of a visible method declaration with that name, then there must be an enclosing type declaration of which that method is a member. Let T be the innermost such type declaration. The class or interface to search is T.

[Ray Stojonic]

I think it's saying that the method to look for in a simple method call should be looked for in the most immediate enclosing class or interface, relative to the call.
Defined this way, recursive method calls are also covered.

[Alton Hernandez]

Hi Marlene,
This is how I understood it:

class t7 {
   void m(){
     System.out.println("t7 m()");
   }
   [B]class t7i {[/B]
      void m() {
          System.out.println("t7i m()");
      }
      void aMethod() {
         [B]m();[/B]
      }
   }
}

In this case, is t7i the innermost class or interface that it is talking about?

[Marlene Miller]

Thank you Ray and Alton for considering my question.
Alton, I think the JLS uses innermost to mean a relationship between nested classes and enclosing classes. From your example, it looks like you would agree.
Now, is there an innermost class in this example?

class A {}
class B extends A{}
//
class S {
    static void m(A x, B y) {}
}
//
class T extends S {
    static void m(B x, A y) {}
    public static void main(String[] args) {
        B b = new B();
        m(b, b);
    }
}

What confuses me is, we know that m(A x, B y) is a member of both S and T. And m(B x, A y) is a member of T. Is T innermost?
Who would have thought a subclass is innermost in relation to its superclass?

[Alton Hernandez]

Originally posted by Marlene Miller:

Who would have thought a subclass is innermost in relation to its superclass?

Hi Marlene,
In your last example, if the subclass T is the innermost and S is the outermost, then why does the compiler have to consider the method in S which would cause a compiler error? Shouldn't it had stopped once it found the method in T?
If you would compare this with my example, the compiler is not complaining that there is no most specific method, because it is not considering the outer method.

[Marlene Miller]

Hi Alton,

In your last example, if the subclass T is the innermost and S is the outermost, then why does the compiler have to consider the method in S which would cause a compiler error?

Because the method in S is a member of T.

class A {}
class B extends A{}
// example 1: 
class S1 {
    void m(A x, B y) {}
    class T1 {
        void m(B x, A y) {}
        void t() {
            B b = new B();
            m(b,b); // compiles okay, not ambiguous
        }
    }
}
// example 2:
class S2 {
    void m(A x, B y) {}
}
class T2 extends S2 {
    void m(B x, A y) {}
    void t() {
        B b = new B();
        m(b,b);  // compiler error, ambiguous
    }
}

In example 1, m(A x, B y) is a member of S1, m(B x, A y) is a member of T1. T1 is the innermost type.
In example 2, m(A x, B y) is a member of both S2 and T2, m(B x, A y) is a member of T2. I guess T2 is the innermost type.

[Alton Hernandez]

Because the method in S is a member of T.
Which is my point. If there is an innermost boundary, the compiler would not have seen the other method in S. The method is already resolved in T.

[Marlene Miller]

Well, I am getting lazy. I almost forgot to thank you Alton for you time and opinions.