No, you can’t, and no, the compiler can’t figure it out. This is why FindBugs always suggests changing anonymous inner classes to named static nested classes if they don’t use their implicit this reference. Edit: Tom Hawtin – tackline says that if the anonymous class is created in a static context (e.g. in the main … Read more
Intro: Nested classes relate to other classes a little differently than outer classes. Taking Java as an example: Non-static nested classes have access to other members of the enclosing class, even if they are declared private. Also, non-static nested classes require an instance of the parent class to be instantiated. OuterClass outerObj = new OuterClass(arguments); … Read more
You have to have a reference to the other outer class as well. Inner inner = new MyClass().new Inner(); If Inner was static then it would be Inner inner = new MyClass.Inner();
An inner class is a friend of the class it is defined within. So, yes; an object of type Outer::Inner can access the member variable var of an object of type Outer. Unlike Java though, there is no correlation between an object of type Outer::Inner and an object of the parent class. You have to … Read more
Because an instance of an inner class is implicitly associated with an instance of its outer class, it cannot define any static methods itself. Since a static nested class cannot refer directly to instance variables or methods defined in its enclosing class, it can use them only through an object reference, it’s safe to declare … Read more
You’re trying to access Outer’s class instance, from inner class instance. So just use factory-method to build Inner instance and pass Outer instance to it. class Outer(object): def createInner(self): return Outer.Inner(self) class Inner(object): def __init__(self, outer_instance): self.outer_instance = outer_instance self.outer_instance.somemethod() def inner_method(self): self.outer_instance.anothermethod()
The inner class is just a way to cleanly separate some functionality that really belongs to the original outer class. They are intended to be used when you have 2 requirements: Some piece of functionality in your outer class would be most clear if it was implemented in a separate class. Even though it’s in … Read more
Nested classes are cool for hiding implementation details. List: class List { public: List(): head(nullptr), tail(nullptr) {} private: class Node { public: int data; Node* next; Node* prev; }; private: Node* head; Node* tail; }; Here I don’t want to expose Node as other people may decide to use the class and that would hinder … Read more
A pattern that I particularly like is to combine nested classes with the factory pattern: public abstract class BankAccount { private BankAccount() {} // prevent third-party subclassing. private sealed class SavingsAccount : BankAccount { … } private sealed class ChequingAccount : BankAccount { … } public static BankAccount MakeSavingAccount() { … } public static BankAccount … Read more
Within the inner class itself, you can use OuterClass.this. This expression, which allows to refer to any lexically enclosing instance, is described in the JLS as Qualified this. I don’t think there’s a way to get the instance from outside the code of the inner class though. Of course, you can always introduce your own … Read more