CodeGym/Java Course/Java Multithreading/Inheriting nested classes

Inheriting nested classes

Java Multithreading

Level 4, Lesson 3

Available

"Hi, Amigo!"

"Hi, Kim."

"I want to tell you about inheriting static and non-static nested classes."

"I'm ready."

"There really aren't any issues with inheriting static nested classes. They are inherited just like regular classes:"

Example

public class Car
{
 public static class Door
 {

 }
}

public class LamborghiniDoor extends Car.Door
{
}

"But can we make static nested classes inherit static nested classes in other classes?"

"Why not?"

Example

public class Car
{
 public static class Door
 {

 }
}

public class Lamborghini extends Car
{
 public static class LamborghiniDoor extends Car.Door
 {
 }
}

"OK, got it. They are inherited just like regular classes, right?"

"Yes. But non-static nested classes (known as inner classes) are not inherited as easily."

"When an instance of an inner class is created, a reference to its outer class is stored and implicitly passed to the constructor."

"As a result, when you create objects of a class that inherits an inner class, you must pass the required outer object explicitly."

"This is how it looks:"

Code

public class Car
{
 public class Door
 {

 }
}

public class LamborghiniDoor extends Car.Door
{
 LamborghiniDoor(Car car)
 {
  car.super();
 }
}

"You must implicitly pass a Car object to the Door constructor. This is done using a special construct: «car.super()»."

"By the way, if you try to create the LamborghiniDoor constructor without any parameters, the program simply won't compile. A little strange, huh?"

"Yeah, there are a couple of nuances, but it's not rocket science."

PreviousPrevious lesson

NextNext lesson

Comments (14)

Popular
New
Old

You must be signed in to leave a comment

Justin Smith

Level 41 , Greenfield, USA, United States

13 January 2022, 01:47

Inheriting a nested class from outside the parent class, while possible, might be an indication that the project hasn't been planned out well.

Dawid

Level 28

30 March 2021, 01:22

I would like to explain the syntax thing raised in the comments regarding car.super() call. So when we have super() call in the constructor, it always means that the constructor of the direct superclass will be invoked. So in this case we have constructor of the LamborghiniDoor class therefore Car.Door contructor will be called. Moving on to nested classes we know, an inner class object will not be created without its outer class object so the instance of a enclosing class(Car class) is needed to execute the constructor of inner class(Car.Door). That's why we need to send an instance of Car class to the constructor in LamborghiniDoor the class and therefore we also have this rare syntax ( car.super() ) because by calling the constructor of Car.Door we need to indicate a specific object of the Car class on which this constructor will base it's work.

Andrei

Level 41

7 April 2021, 11:18

Ah, ok, that makes more sense. Great point! Here is a formatted version if you want to update your, to make it more easier to read/understand. I would like to explain the syntax situation raised in the comments regarding car.super() call. When we have super() call in the constructor, it always means that the constructor of the direct superclass will be invoked. So in this case we have constructor of the LamborghiniDoor class therefore Car.Door constructor will be called. Moving on to nested classes we know, an inner class object will not be created without its outer class object so the instance of a enclosing class(Car class) is needed to execute the constructor of inner class(Car.Door). That's why we need to send an instance of Car class to the LamborghiniDoor constructor and therefore we also have this rare syntax ( car.super() ). By calling the constructor of Car.Door we need to indicate a specific object of the Car class on which this constructor will base it's work.

John Squirrels Website Admin at CodeGym

8 April 2021, 08:26

Hey, Andrei. We sent you the needed links. Please check your DM.

matemate123

Level 50 , Kraków, Poland

12 April 2023, 16:44

Why DM, not here? ...

John Squirrels Website Admin at CodeGym

12 April 2023, 17:17

Here you are: Nested inner classes Static nested classes Inner classes in a local method

Johannes

Level 27 , Centurion, Pretoria, South-Africa

5 May 2020, 10:13

why car.super(); ? Car class doesn't have a super in this example ?

Vesa

Level 41 , Kaliningrad, Russia

11 May 2020, 10:37

This is the syntax for calling the constructor of the Car.Door class, which is the superclass for the LamborginiDoor class. This is a way to implicitly pass a Car object to the Door constructor.

public static void main(String[] args) {
        new LamborginiDoor(new Car());
}

Car constructor Car.Door constructor LamborginiDoor constructor

Wei Cui

Level 39 , Newark, United States

8 April 2020, 04:07

for the second example, there are two way to write, the other way may easier to understand;

public class LamborginiDoor extends Car.Door
{
 LamborginiDoor()
 {
  new car.super();
// new car().new door()  door method is non static method so must create new reference to use , so super key word could reference every suplerclass method
 }
}

Vahan

Level 41 , Tbilisi, Georgia

31 January 2020, 07:39

In second example - static nested classes inherit static nested classes in other classes - parent class Lamborgini inherits Doors parent class Car. Is it necessary for inheritance of nested static classes to take place?

John

Level 27 , Washington DC, USA

23 January 2020, 22:10

What does car.super() do in the last example? It would seem to call the car's parent class which is implicitly Object. If so, I don't know why super is being used.

Marcin Olech

Level 41 , Kraków, Poland

12 October 2019, 12:36

Hmm, i'm a bit confused. When I tried to compile the code from this lesson it says that "Inner classes cannot have static declarations." But in this lesson they do, what I am missing?

Juanf Software Developer

2 November 2019, 09:03

Yup, I think that Lamborgini should be in a separate file, as it is also public, and it is not nested. Nested classes in the example are Door and LamborginiDoor , both not inner, but nested classes (both are static). If you create both files for Car and Lamborgini, each with its nested class, it works perfectly.

Hossein Shams

Level 26 , Atlanta, United States

15 November 2019, 00:40

Or you can make everything be inner classes of a bigger outer class, like Solution