Why inner class have access to private field of input object param of such class?
private class Inner {
private int privatefield = 0;
public void method( Inner inner ) {
privatefield = 1; //ok
inner.privatefield = 1; //this line confusing me (broken incapsulation)
}
}
This has nothing to do with inner classes per se.
The code within a class always has access to private members of the same class in Java. The notion of private/public etc refers to where the code lives, not whether it refers to "this" instance or a different one. Protected access is a little bit more complicated than other access, but the same general principle applies.
See JLS section 6.6 for more details. In particular:
Otherwise, if the member or constructor is declared private, then 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.
And that explains why one nested class has access to another nested class's private fields, so long as they're nested within the same top-level class, as per your comments. It's an odd rule, I agree - and I prefer C#'s approach in terms of private accessibility and nested types - but the above quote shows that the compiler is obeying the rules of the JLS.
I suspect the reasoning is that if you're working within the same top-level class, you're responsible for all the code within that class, including the nested classes - so you're trusted not to abuse them.
Why inner class have access to private field of input object param of such class?
private, inner class is a member of outer classprivate members are accessible for the class members.
Consider that your class isn't nested neither private, cause it's irrelevant with your question. It has to do with scope visibility.
private modifier — the field is accessible only within its own class.
Since you access the privatefield property inside the class that is declared even if it's a member of a different instance your encapsulation isn't broken,private scope is maintained.
Any method within a class can access a global variable inside that class. The private parameter only makes it so that OTHER classes can not access the variable.
In this case the methods in Inner will be able to find the var and methods outside of Inner will not be able to.
If you see Docs of Controlling Access to Members of a Class
The private modifier specifies that the member can only be accessed in its own class.
Since privatefield is member of your class, you have access inside the class.
Since the method(Inner inner) resides in the Inner class, hence method(Inner inner) can access the member private to the Inner class.
Access modifiers define the scope in which your variable can be accesses and not whether individual instances can access it or not!
private int privatefield = 0;
Your variable is non static so it will be accesses by instance of the class. So inner.privatefield makes sense. Now your variable privatefield is private which means you can access it inside your Inner class. Since your are accessing the variable inside method() which is inside Inner class there is no problem and is perfectly valid.
