How does Java inheritance work when inner classes are involved

Question

I am having trouble understanding how inheritance works in Java when inner classes are present. I\'m currently working on something where a child class needs to slightly ch

Answer 1

In general, what is the recommended way of altering the behavior of an object's parent class's inner object?

I'd recommend using a less convoluted design to begin with. A child class should modify the behaviour of its parent by overriding its methods, so I'd just add some factory method newInnerClass() to override the creation of this dependency, and manage this object at the top of the class hierarchy.

This would be more flexible than what you propose, because newInnerClass() could instantiate a class that's defined wherever as long as it has the right interface.

Answer 2

Remove the redeclaration

InnerClass x; 

from the child class. So, that you will have only one x and will be reassigned in the constructor of the child class. Which means one x (refering to the object created in child ctor).

It's hiding the one in the parent class. Which is why you end up having two fields, refering to two different objects. And due to static (compile-time or early) binding in case of variables,

ParentClass obj; 
//obj.x means the x in parent

and

ChildClass obj; 
//obj.x means the x in child

Answer 3

Variable are not "overriden" as methods are.

In your call, you expected x to be the Child's one but it isn't because x is a variable, not a method.

But pay attention: Your reference type is ParentClass so obj.x points to the ParentClass's InnerClass attribute even though the real instance behind parentClass is a ChildClass!

In order to display your expected sentence, you have to change the type reference to ChildClass:

public static void main(String[] args) {
      ChildClass obj = (new InnerClassTest()).new ChildClass();
      obj.x.speak();
}

To better understand the concept, try to define a method in both ParentClass and ChildClass classes:

public InnerClass getInnerClass(){
  return x;
}  

and make x private.

so that "override concept" applies.

Your final call would be in this case:

ParentClass obj = (new InnerClassTest()).new ChildClass();
obj.getInnerClass().speak();

To alter the behavior of the inner classes, think of Template method pattern or better: Strategy pattern (since more respectful of DIP)