Introduction
Inheritance is a mechanism to create a sub class that inherits the attributes and behaviours from the parent class. Basically, the class that created in Java is automatically inherits from the Object
class.
Usually, the parent class is a general abstraction of an entity. The sub class is a specific abstraction of an entity. The inheritance mechanism is illustrated in this picture.
Creating Inheritance
To create an inheritance, use the extends
keyword followed with the parent class. In this example, the two classes is created called Car
and RaceCar
. The Car
acts as a parent class and the RaceCar
acts as a sub class. The relation between Car
and RaceCar
is illustrated in this picture below.
Car class
public class Car {
private String manufacturer;
private String model;
public Car(String manufacturer, String model) {
this.manufacturer = manufacturer;
this.model = model;
}
public void run() {
System.out.println("Running...");
}
public String getManufacturer() {
return manufacturer;
}
public void setManufacturer(String manufacturer) {
this.manufacturer = manufacturer;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
}
RaceCar class
public class RaceCar extends Car{
// additional field for race car class
private String teamName;
public RaceCar(String manufacturer, String model, String teamName) {
// call the parent's constructor using super()
super(manufacturer, model);
this.teamName = teamName;
}
// implement run() for race car class
@Override
public void run() {
System.out.println("Running with racing spec");
}
public String getTeamName() {
return teamName;
}
public void setTeamName(String teamName) {
this.teamName = teamName;
}
}
Main Class
public class MyApp {
public static void main(String[] args) {
RaceCar car = new RaceCar("Porsche","911 GT3","Manthey Racing");
car.run();
}
}
Output
Running with racing spec
Based on the code above, the RaceCar
is extends all the fields and methods in Car
class so the fields and methods inside Car
class is also available in RaceCar
class. Notice that the super()
is used inside the RaceCar
constructor to call the parent's constructor.
The RaceCar
class overrides the method from Car
class called run()
with @Override
annotation. @Override
basically means define the specific implementation in the parent's method in this case the run()
method.
The simple way to understand the inheritance code is replace the
extends
withis a
word.
In this case, the RaceCar
is a Car
so the object from RaceCar
class can be stored in a variable with the Car
type.
public class MyApp {
public static void main(String[] args) {
Car raceCar = new RaceCar("Toyota","GT-One","Toyota Racing");
raceCar.run();
}
}
Output
Running with racing spec
Based on the cove above, the run()
method is called from RaceCar
class.
Notes
The multiple inheritance is not supported in Java. The multiple inheritance means a class can inherits many parent classes. This is the illustration of multiple inheritance.
The multilevel inheritance is supported in Java. This is the illustration of multilevel inheritance.
Sources
- Learn more about inheritance in this link.
I hope this article is helpful for learning the Java programming language. If you have any thoughts or comments you can write in the discussion section below.
Top comments (0)