Why can I inherit final method from inner class?

Question

I discovered that following code compiles:

class Ideone
{
    public static void main (String[] args){
         new Ideone().m();
    }

    final private void m(){
        System.out.println("private final method");
    }

     class A extends Ideone{
        public  void method(String [] args){
           m();
        }
    }
}

and executes.

I am very wondering about this.

Can you explain why does java designers(founders) made that it works?

You can call *private* method `Ideone#m()` because class `A` is in the scope of class `Ideone`. Not sure if this is what you mean? — clstrfsck, Mar 31 '15 at 22:14
And in case it was really the `private` you're worried about - `private` methods are accessible to all code which is within the top-level class declaration, including code in nested class declarations. — Jon Skeet, Mar 31 '15 at 22:14
I was confusing because private is accessible from inner class. I supposed that it is reason why private methods inheritance is forbidden for top level classes — gstackoverflow, Mar 31 '15 at 22:33

score 0 · Answer 1 · answered Mar 31 '15 at 22:14

A final method can be inherited by a sub class regardless the sub class is outside the parent class or inside the parent class. But you cannot override the final method in your subclass. If the final method is private you cannot inherit that in your subclass unless your subclass is inside the parent class (like in your example).

thomas77 · Answer 2 · 2015-03-31T23:07:13.123

Since you declare the method private, then final has no effect and is redundant.

Overriding a private method don't really make much sense.

It is no different then calling a private method in a class from another method in the same class (which might be public). That is something that is done often to keep code more readable and method's manageable in size.

I don't think it is a stupid question :)

Take the Builder-pattern for example. It utilizes private constructors to make sure the class is constructed the correct way. So understanding what you have available in different scope's, and why is important :)

class Ideone {
private String m;

private Ideone(String m) {
    System.out.println("Build me with: " + m);
    this.m = m;
}

public String getM() {

    return m;
}

static class IdeoneBuilder{
    String m;

    public IdeoneBuilder withM(String m) {
        this.m = m;
        return this;
    }

    public Ideone build() {
        return new Ideone(this.m);
    }

}

public static void main (String[] args){
    // new Ideone(); // will not compile
    Ideone ideone = new IdeoneBuilder()
            .withM("test").build();
}
}

Edit: You can make the class Ideone final, and it will still work. And you are also making it impossible to subclass it. In other words, you make sure there is no other way to construct an object of your class other than using the builder (unless the use of reflection).

Why can I inherit final method from inner class?

2 Answers2