inner class have access to private final methods in base class but why?

Question

Why creators of java allowed this situation? I am sure there must be some reason for it. My below code allows Lion to mischievously run as fast as Cheetah.

public class animal {
    class carnivores {
       private final void runAsFastAsCheetah() {
           System.out.println("Ran as fast as Cheetah");
        }
    }
    public class Lion extends carnivores {
       public void runAsFastAsLion() {
           System.out.println("Ran as fast as Lion.");
           super.runAsFastAsCheetah();
        }
    }
    public static void main(String[] args) {
        animal animal = new animal();
        Lion lion = animal.new Lion();
        //lion.runAsFastAsCheetah(); //Not allowed but//
        lion.runAsFastAsLion();
    }
}

EDIT: For those taking Lion and cheetah seriously, I have modified code.

public class foo {
    class A {
        private final void myMethod() {
            System.out.println("in private final myMethod()");
        }
    }
    public class B extends A {
        public void myMethod() {
            System.out.println("in B's myMethod()");
            super.myMethod();
        }
    }
    public static void main(String[] args) {
        foo foo = new foo();
        B b = foo.new B();
        b.myMethod();
    }
}

Well..how do you think? What does the `private` word mean? :) — Konstantin Yovkov, Jul 10 '14 at 13:25
The only question here is why all carnivores can run as fast as a Cheetah. — Keppil, Jul 10 '14 at 13:29
@Keppil I have made an EDIT in question. Try answering now. thanks — instinct, Jul 10 '14 at 13:57

Peter Lawrey · Accepted Answer · 2014-07-10T18:46:06.357

2

All classes with the same outer class can access private members of any other class of the same outer. This features was added when nested classes were added. IMHO this was because these members are compiled together and it makes nested classes more useful.

Note: The JVM doesn't support this feature, and thus the compiler add accessor methods which appear the the stack traces like access$100. These are added by the compiler to allow access to private members between classes.

Access modifiers only check one level. If A can access B and B and access C, then A can access anything B lets it access which could be C.

The reason this is don't is to avoid making private meaningless. If a private member could only be accessed by class which could access it, it would mean it could only be called by a main in the same class. This would make it useless in any other class.

edited Jul 10 '14 at 18:46

answered Jul 10 '14 at 13:29

Peter Lawrey

525,659
79
751
1,130

If the two classes `carnivores` and `Lion` were not inner classes, then `Lion` wouldn't be able to access `runAsFastAsCheetah()`. – Jamie Cockburn Jul 10 '14 at 13:47
@JamieCockburn exactly. They are allowed only in inner class situation, which I was trying to ask, why. – instinct Jul 10 '14 at 13:54
@JamieCockburn Don't conflate inner classes and nested classes. – chrylis -cautiouslyoptimistic- Jul 10 '14 at 15:56
@chrylis How am I conflating those two ideas? I haven't mentioned the term "nested classes" anywhere? – Jamie Cockburn Jul 10 '14 at 16:01
@chrylis And also, since inner classes are nested classes (but not the other way around), then you can conflate them in many situations! – Jamie Cockburn Jul 10 '14 at 16:02
@JamieCockburn Visibility rules apply to nesting. Static nested classes have the same visibility as inner classes. – chrylis -cautiouslyoptimistic- Jul 10 '14 at 16:09
@chrylis So you're bascialy saying that my original comment applies to all nested classes, whether they be static or inner? – Jamie Cockburn Jul 10 '14 at 16:11
1

@SandeepPareek I miss understood the question. members of the same outer class can access each other as they are compiled as unit. I guess your left hand doesn't need to be protected from your right hand. – Peter Lawrey Jul 10 '14 at 18:47

Jamie Cockburn · Answer 2 · 2014-07-10T13:59:47.087

From the Java Language Specification:

A member (class, interface, field, or method) of a reference type, or a constructor of a class type, is accessible only if the type is accessible and the member or constructor is declared to permit access:

...

Otherwise, the member or constructor is declared private, and access is permitted if and only if it occurs within the body of the top level class (§7.6) that encloses the declaration of the member or constructor.

In other words, within a top-level class, private and protected no longer apply.

As for the why, well if you think of everything in a class being accessible by that class, then that includes everything inside any inner classes too!

inner class have access to private final methods in base class but why?

2 Answers2