Clean • Professional
Inheritance is one of the four core concepts of Object-Oriented Programming (OOP) in Java.
It allows one class to acquire properties and behaviors (fields and methods) of another class — helping you reuse, extend, and maintain code more easily.
Inheritance in Java is a mechanism where one class (child/subclass) derives the properties and methods of another class (parent/superclass).
It is implemented using the extends keyword.
class Parent {
// fields and methods
}
class Child extends Parent {
// inherits Parent’s members
}
| Benefit | Description |
|---|---|
| Code Reusability | Avoid writing the same code multiple times. |
| Improved Maintainability | Update logic in one place (parent class). |
| Extensibility | Easily add new features via subclasses. |
| Polymorphism | Allows dynamic behavior using method overriding. |
A Vehicle can be the parent class, and Car, Bike, Truck can be subclasses.
class Vehicle {
void start() {
System.out.println("Vehicle is starting...");
}
}
class Car extends Vehicle {
void honk() {
System.out.println("Car is honking!");
}
}
public class InheritanceExample {
public static void main(String[] args) {
Car car = new Car();
car.start(); // inherited method
car.honk(); // own method
}
}
Output:
Vehicle is starting...
Car is honking!
class SubclassName extends SuperclassName {
// body of subclass
}
class Dog extends Animal { }
Here,
Animal → Parent Class (Superclass)Dog → Child Class (Subclass)| Term | Meaning |
|---|---|
| Superclass (Parent Class) | The class whose members are inherited. |
| Subclass (Child Class) | The class that inherits the superclass members. |
| extends keyword | Used to define inheritance. |
| super keyword | Refers to parent class members. |
Java supports several categories of inheritance, depending on how classes are related.
One class inherits from another single class.
class A {
void showA() { System.out.println("Class A"); }
}
class B extends A {
void showB() { System.out.println("Class B"); }
}
public class SingleInheritance {
public static void main(String[] args) {
B obj = new B();
obj.showA();
obj.showB();
}
}
Output:
Class A
Class B
Used When: One class needs the functionality of one parent class.
A chain of inheritance (one class inherits from another derived class).
class A {
void methodA() { System.out.println("A class"); }
}
class B extends A {
void methodB() { System.out.println("B class"); }
}
class C extends B {
void methodC() { System.out.println("C class"); }
}
public class MultilevelExample {
public static void main(String[] args) {
C obj = new C();
obj.methodA();
obj.methodB();
obj.methodC();
}
}
Output:
A class
B class
C class
Used When: You want features to build layer-by-layer.
Multiple subclasses inherit from a single parent class.
class Animal {
void eat() { System.out.println("Animals eat food"); }
}
class Dog extends Animal {
void bark() { System.out.println("Dog barks"); }
}
class Cat extends Animal {
void meow() { System.out.println("Cat meows"); }
}
public class HierarchicalExample {
public static void main(String[] args) {
Dog d = new Dog();
d.eat();
d.bark();
Cat c = new Cat();
c.eat();
c.meow();
}
}
Output:
Animals eat food
Dog barks
Animals eat food
Cat meows
Used When: Different classes share common properties/methods.
Java does not support multiple inheritance with classes to avoid ambiguity (the “diamond problem”).
However, it supports multiple inheritance using interfaces.
interface A {
void display();
}
interface B {
void print();
}
class C implements A, B {
public void display() { System.out.println("Display method"); }
public void print() { System.out.println("Print method"); }
}
public class MultipleInheritanceExample {
public static void main(String[] args) {
C obj = new C();
obj.display();
obj.print();
}
}
Output:
Display method
Print method
Used When: You need a class to follow multiple behavior contracts.
A combination of two or more types of inheritance. Not directly supported by Java (to avoid ambiguity), but can be achieved using interfaces.
Example: Hierarchical + Multiple via interfaces.
super().super keyword helps access parent methods, variables, and constructors.class Employee {
int salary = 40000;
}
class Developer extends Employee {
int bonus = 10000;
}
public class RealLifeExample {
public static void main(String[] args) {
Developer d = new Developer();
System.out.println("Salary: " + d.salary);
System.out.println("Bonus: " + d.bonus);
}
}
Output:
Salary: 40000
Bonus: 10000