Why does an inner class method hide all the enclosing class methods with the same name?

Question

Considering the java code below:

class Enclosing {
    void method(){}
    void method(String str){}

    class Inner {
        void method(){}
    }   
}

I am reading a book which tells me that Inner.method() will hide both versions of Enclosing.method(), which means it is an error if I call method(aString) somewhere in class Inner.

Why is the language designed like that?

Update:
According to the answer given by @Debosmit Ray, it is related to shadowing. I have read the docs and understood what it is.

What still confusing me is why method shadowing is based on method name not method signature?

Answer 1

Non-static nested class or inner classes are used as a way to logically group classes that are only used in one place; it makes the code more readable and promotes encapsulation.

From [docs],

If a declaration of a type (such as a member variable or a parameter name) in a particular scope (such as an inner class or a method definition) has the same name as another declaration in the enclosing scope, then the declaration shadows the declaration of the enclosing scope.

Shadowing here would mean that if you have a variable x in the outer class and another variable x in the inner class, modifying x in the inner class would not affect the x in the outer class.

I quite liked this question and the point you brought up. Does my explanantion help you understand?

Answer 2

Had you found the correct tag for your question, you would have understood the concept better already! Take look at the tag info for shadowing right on SO.

In computer programming, shadowing occurs when a variable declared within a certain scope (decision block, method or inner class) has the same name as a variable declared in an outer scope. This can lead to confusion, as it may be unclear which variable subsequent uses of the shadowed variable name refer to, which depends on the name resolution rules of the language.

One of the first languages to introduce variable shadowing was ALGOL, which first introduced blocks to establish scopes. It was also permitted by many of the derivative programming languages including C++ and Java.

The C# language breaks this tradition, allowing variable shadowing between an inner and an outer class, and between a method and its containing class, but not between an if-block and its containing method, or between case statements in a switch block.

Wikipedia link (doesn't provide much though)

---

Why is the language designed like that?

Let me give you a real world analogy to might help you understand.

Think of a building (1) that has a button named Turn on lights (3). When you press that button, it turns on all the lights in the building. Now think of a cubicle (2) inside that building. There is a small lamp in that cubicle, and a similar button named Turn on lights. Now when you press that button, what do you want it to do -- turn on all the lights of the building, or just the lamp in the cubicle? Probably the latter. Though both the buttons have the same name (4), they behave differently depending on their place (5).

Now apply this analogy to OOP. Look at the words in italics one more time, and match up!

1. building --> Enclosing class
2. cubicle --> Inner class
3. Turn on lights --> Method
4. name --> Method name/signature
5. place --> Scope

Please note that the analogy doesn't take into consideration many other concepts of OOP, but I think it might help you understand the why part of your question.

---

Reply to Update:

What still confusing me is why method shadowing is based on method name not method signature?

Your question doesn't seem to be a valid one. You will understand this shortly.

You said shadowing is not based on method signature. If what you mean by this is: "if inner class method has same signature as enclosing class method, then shadowing doesn't take place", then you are wrong. Try it out by making a another method inside the inner class like void method(String str) and then calling that method inside the inner class. You will see that it is obviously shadowed.

And the reason why you got an error when you invoked method(aString) inside the inner class is completely something else-- the method method(String str) doesn't even exist inside the inner class scope.

Feel free if you need further clarification.

Answer 3

This is called shadowing.

According to JLS 6.4.1

Some declarations may be shadowed in part of their scope by another declaration of the same name, in which case a simple name cannot be used to refer to the declared entity.

It's convenient to have shadowing in programming language. For example, in constructors, you can have both parameters and class field variables the same name, and use this to distinguish them.

class Person {
    private String name;
    Person (String name) {
        this.name = name;
    }
}

In some other languages, variables may be shadowed by code blocks, for example, in C++ you can write code like:

// C++ code:
int i = 10;

for(int i = 0; i != 5; ++i) {
    // use i from 0 to 4 here
}

for(int i = 100; i > 0; --i) {
    // use i from 100 to 1 here
}

// the first i is still 10 and can be used here

The variable i inside the loop is different from the outside i.

Why is the language designed like that?

As you can see in the constructor example, sometimes variables may really mean the same thing. Shadowing makes you can use the same names without creating a new name, which is kind of bothering because naming a variable is not quiet simple.

And in the loop sample, which is not supported in Java but is a great sample to show the advantage of shadowing, sometimes in code block you may declared some temporary variables without modifying other variables outside the block.

---

Why method shadowing is based on method name not method signature?

In JLS 15.12, there's a explanation about method invocation.

You can see that in step 1, compiler will search for the scope that can call this method. In the end, it found Enclosing.Inner.

And at step 2, compiler will check signature of the methods.

Therefore, compiler will take Enclosing.Inner.method() as the only method that is available to call. That's why you can't call Enclosing.method(String str) directly, even though they have different method signature.

If you want to call Enclosing.method(String str) inside the Inner class, you can do:

class Inner {
    void method(){
        Enclosing.this.method("test");
    }
}

Answer 4

Because in that Scope, Method, Variables and constants make shadow over global method and variables...