Java Inheritance - Parent and Child Classes in OOP

⏱️ 20 min read • Beginner Level • Lesson 50

Inheritance in Java is an important object-oriented programming concept where one class can acquire the properties and behaviors of another class. It helps you reuse code, organize classes, and build relationships between objects.

In this lesson, you will learn Java inheritance deeply with the extends keyword, parent and child classes, types of inheritance, constructor execution order, super keyword, method overriding, protected access, upcasting, tricky cases, common mistakes, and interview questions. Before learning inheritance, you should understand Java Class and Objects, Java Class Members, Java Constructors, and Java this Keyword.

What is Inheritance in Java?

Inheritance is a mechanism in Java where one class can use the variables and methods of another class. The class that gives members is called the parent class, and the class that receives members is called the child class.

Real-World Analogy

Think about a general Vehicle. A Car is a type of Vehicle, and a Bike is also a type of Vehicle.

        Vehicle
      /         \
    Car         Bike
                  \
                SportsBike
                        

Why Use Inheritance?

Inheritance is used when multiple classes share common properties or behavior. Instead of writing the same code again and again, common code is written in a parent class.

Important Terms in Inheritance

Syntax of Inheritance in Java

class ParentClass {
    // parent class members
}

class ChildClass extends ParentClass {
    // child class members
}

Basic Inheritance Example

class Animal {
    void eat() {
        System.out.println("Animal eats food");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.bark();
    }
}

Output:

Animal eats food
Dog barks

Types of Inheritance in Java

Java supports inheritance in different forms. Some are directly supported through classes, and some are achieved through interfaces.

Single Inheritance in Java

Single inheritance means one child class inherits from one parent class.

class Vehicle {
    void start() {
        System.out.println("Vehicle starts");
    }
}

class Car extends Vehicle {
    void drive() {
        System.out.println("Car drives");
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.drive();
    }
}

Output:

Vehicle starts
Car drives

Multilevel Inheritance in Java

Multilevel inheritance creates a chain of inheritance. For example, Dog inherits from Mammal, and Mammal inherits from Animal.

class Animal {
    void eat() {
        System.out.println("Animal eats");
    }
}

class Mammal extends Animal {
    void walk() {
        System.out.println("Mammal walks");
    }
}

class Dog extends Mammal {
    void bark() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.walk();
        dog.bark();
    }
}

Output:

Animal eats
Mammal walks
Dog barks

Hierarchical Inheritance in Java

Hierarchical inheritance means multiple child classes inherit from the same parent class.

class Shape {
    void draw() {
        System.out.println("Drawing shape");
    }
}

class Circle extends Shape {
    void circleInfo() {
        System.out.println("This is a circle");
    }
}

class Rectangle extends Shape {
    void rectangleInfo() {
        System.out.println("This is a rectangle");
    }

    public static void main(String[] args) {
        Circle c = new Circle();
        c.draw();
        c.circleInfo();

        Rectangle r = new Rectangle();
        r.draw();
        r.rectangleInfo();
    }
}

Output:

Drawing shape
This is a circle
Drawing shape
This is a rectangle

Multiple Inheritance and Java

Java does not support multiple inheritance using classes. This means one class cannot extend two classes at the same time.

class A {
}

class B {
}

class C extends A, B { // Error
}

Output:

Compilation Error

Constructor Execution Order in Inheritance

When a child class object is created, the parent class constructor executes first, then the child class constructor executes.

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child constructor");
    }

    public static void main(String[] args) {
        Child obj = new Child();
    }
}

Output:

Parent constructor
Child constructor

super Keyword Introduction

The super keyword refers to the parent class part of the current object. It is commonly used to call parent class constructor, parent class method, or parent class variable.

✓ call parent constructor

✓ call parent method

✓ access parent variable

class Parent {
    void show() {
        System.out.println("Parent show method");
    }
}

class Child extends Parent {
    void show() {
        super.show();
        System.out.println("Child show method");
    }

    public static void main(String[] args) {
        Child c = new Child();
        c.show();
    }
}

Output:

Parent show method
Child show method

Method Overriding Introduction

Method overriding happens when a child class provides its own implementation of a method that already exists in the parent class.

class Animal {
    void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound();
    }
}

Output:

Dog barks

protected Members in Inheritance

A protected member can be accessed in the same package and also in child classes. It is often used when parent class data or behavior should be available to subclasses.

class Employee {
    protected double salary = 50000;
}

class Developer extends Employee {
    void showSalary() {
        System.out.println("Salary: " + salary);
    }

    public static void main(String[] args) {
        Developer d = new Developer();
        d.showSalary();
    }
}

Output:

Salary: 50000.0

Upcasting in Inheritance

Upcasting means storing a child class object in a parent class reference variable. This is allowed because the child object is also a type of parent.

A Dog object is also an Animal because Dog extends Animal. Therefore, storing a Dog object in an Animal reference is called upcasting.

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
    }
}

Output:

Dog barks

Downcasting in Java

Downcasting means converting a parent class reference back into a child class reference. It requires explicit casting.

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Animal a = new Dog(); // Upcasting

        Dog d = (Dog) a; // Downcasting
        d.bark();
    }
}

Output:

Dog barks

Inheritance Represents IS-A Relationship

Use inheritance only when the child class is truly a type of the parent class.

Tricky Cases: If This, Then What Happens?

1. Are private members inherited?

class Parent {
    private int number = 10;
}

class Child extends Parent {
    void show() {
        System.out.println(number); // Error
    }
}

Output:

Compilation Error

2. Are constructors inherited?

3. What if parent class has only parameterized constructor?

class Parent {
    Parent(String name) {
        System.out.println(name);
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child constructor");
    }
}

Output:

Compilation Error

4. Can final class be inherited?

final class Parent {
}

class Child extends Parent { // Error
}

Output:

Compilation Error

5. Are static methods overridden?

Common Mistakes with Inheritance

Interview Questions ⭐

🧠 Test your understanding with a quick quiz

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        System.out.println("Child constructor");
    }

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

class Animal {
    void eat() {
        System.out.println("Animal eats food");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.bark();
    }
}

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound();
    }
}

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
    }
}

class Parent {
    void show() {
        System.out.println("Parent show");
    }
}

class Child extends Parent {
    void show() {
        super.show();
        System.out.println("Child show");
    }

    public static void main(String[] args) {
        new Child().show();
    }
}

class A { }
class B { }
class C extends A, B { }

🎉 Great job! Continue learning Java OOP step by step.