Inheritance is one of the key features of OOP (Object-oriented Programming) that allows us to define a new class from an existing class. For example,
class Animal
{
// eat() method
// sleep() method
}
class Dog extends Animal
{
// bark() method
}
In Java, we use the extends keyword to inherit from a class. Here, we have inherited the Dog class from the Animal class.
The Animal is the superclass (parent class or base class) and the Dog is a subclass (child class or derived class). The subclass inherits the attributes and methods from the superclass.
It is important to note that only those members that are visible(accessible) from the subclass are inherited by the subclass. To learn more about visibility visit access modifiers.
Inheritance is an is-a relationship. We use inheritance only if an is-a relationship is present between the two classes.
Here are some examples:
class Animal {
public void eat() {
System.out.println("I can eat");
}
public void sleep() {
System.out.println("I can sleep");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.eat();
dog1.sleep();
dog1.bark();
}
}
When you run the program, the output will be:
I can eat I can sleep I can bark
Here, we have inherited a subclass Dog from superclass Animal. The Dog class inherits the methods eat() and sleep() from the Animal class.
Hence, objects of the Dog class can call the methods of both the Dog class and the Animal class.
class Animal {
protected String type;
private String color;
public void eat() {
System.out.println("I can eat");
}
public void sleep() {
System.out.println("I can sleep");
}
public String getColor(){
return color;
}
public void setColor(String col){
color = col;
}
}
class Dog extends Animal {
public void displayInfo(String c){
System.out.println("I am a " + type);
System.out.println("My color is " + c);
}
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.eat();
dog1.sleep();
dog1.bark();
dog1.type = "mammal";
dog1.setColor("black");
dog1.displayInfo(dog1.getColor());
}
}
When you run the program, the output will be:
I can eat I can sleep I can bark I am a mammal My color is black
In the above example, the superclass Animal has the color attribute declared as private. Hence, it is only visible within the superclass Animal. So, the subclass Dog cannot inherit it.
To access the color attribute, we have used public methods getColor() and setColor() inside the superclass Animal.
Also, notice the use of the protected keyword. protected is an access modifier just like public and private.
The protected members are also visible within a package and subclasses. In the above example, the superclass Animal has type attribute declared as protected. Hence, the object of subclass Dog can access it.
From the above examples, we know that objects of a subclass can access methods of the superclass and also define its own methods.,
What happens if the same method is defined in both the superclass and subclass?
Well, in that case, the methods in subclass override the methods in the superclass. For example,
class Animal {
protected String type = "animal";
public void eat() {
System.out.println("I can eat");
}
public void sleep() {
System.out.println("I can sleep");
}
}
class Dog extends Animal {
@Override
public void eat() {
System.out.println("I eat dog food");
}
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.eat();
dog1.sleep();
dog1.bark();
}
}
When you run the program, the output will be:
I eat dog food I can sleep I can bark
Here, methods eat() is present in both the superclass Animal and subclass Dog. We created an object dog1 of the subclass Dog.
When we call eat() method using the dog1 object, the method inside the Dog is called, and the same methods of the superclass are not called. This is called method overriding.
In the above program, we have used the @Override annotation to tell the compiler that we are overriding a method. However, it's not mandatory. We will learn about method overriding in detail in the next tutorial.
If we need to call the eat() method of Animal from the Dog subclass, we use the super keyword.
class Animal {
public Animal() {
System.out.println("I am an Animal");
}
public void eat() {
System.out.println("I can eat");
}
}
class Dog extends Animal {
public Dog(){
super();
System.out.println("I am a dog");
}
@Override
public void eat() {
super.eat();
System.out.println("I eat dog food");
}
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.eat();
dog1.bark();
}
}
When you run the program, the output will be:
I am an Animal I am a dog I can eat I eat dog food I can bark
Here, we have used the super keyword to call the constructor using super(). Also, we have called the eat() method of Animal superclass using super.eat().
Note the difference in the use of super while calling constructor and method. To learn more, visit the super keyword.
There are 5 types of inheritance:
Java doesn’t support multiple and hybrid inheritance through classes. But it can be used with the help of interfaces. We will learn about interfaces in later chapters.