I think you want to declare the HashPerson class as static. Otherwise it can only be instantiated in the context of the containing class, either in a method of the containing class or using code like this: ContainingClass container = new ContainingClass(); HashPerson william = container.new HashPerson(“willy”); Actually, my rule-of-thumb is to make any nested … 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
class Outer(object): outer_var = 1 class Inner(object): @property def inner_var(self): return Outer.outer_var This isn’t quite the same as similar things work in other languages, and uses global lookup instead of scoping the access to outer_var. (If you change what object the name Outer is bound to, then this code will use that object the next … 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
@JsonRawValue is intended for serialization-side only, since the reverse direction is a bit trickier to handle. In effect it was added to allow injecting pre-encoded content. I guess it would be possible to add support for reverse, although that would be quite awkward: content will have to be parsed, and then re-written back to “raw” … 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
Well first, let’s all relax, and please put that gun down. OK. Now the reason the language insists on that is that it cheats in order to provide your inner class functions access to the local variables they crave. The runtime makes a copy of the local execution context (and etc. as appropriate), and thus … 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
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()