Skip to main content

Oops Concepts : Inheritance In Java

When I first started learning Java, inheritance felt a bit confusing. But once I understood the basic idea, it became one of the easiest and most powerful concepts in Object-Oriented Programming (OOP).

In this blog, I’ll explain inheritance in very simple English, so even if you're a beginner student or aspiring developer, you can understand it easily. 

What is Inheritance in Java?

In simple words, inheritance means reusing code from another class.

I usually think of it like this:

  • A child inherits features from parents
  • Similarly, a class can inherit properties and methods from another class

Definition:

Inheritance is a mechanism where a child class gets properties and methods from a parent class.

Key Terms (Very Important)

Parent Class (Superclass) → The class that provides properties

Child Class (Subclass) → The class that inherits those properties

How Inheritance Works in Java

Java uses the keyword:

        extends

Basic Syntax:

This means the Child class can use everything from the Parent class.

Real Example (This Helped Me Understand)

In this example:

  • Animal is the parent class
  • Dog is the child class

What I learned from this:

  • The dog can use eat() from Animal
  • It can also use its own method bark()

This is called code reusability

Types of Inheritance in Java

1. Single Inheritance

This is the simplest type.

One child class inherits from one parent class

Example:

Parent → Child




2. Multilevel Inheritance
This works like a chain.

Grandparent → Parent → Child




I found this useful when building layered applications.


3. Hierarchical Inheritance
 Multiple child classes inherit from one parent


           Parent
       /     \
   Child1   Child2





4. Multiple Inheritance (Using Interfaces)

Java does NOT support multiple inheritance using classes ❌
But it supports it using interfaces ✅



Advantages of Inheritance
From my experience, these are the biggest benefits:

  • Code Reusability → Write once, use many times
  • Less Code → No need to repeat logic
  • Easy Maintenance → Update in one place
  • Method Overriding → Customize behavior
Disadvantages of Inheritance
You should also know the downsides:

  • Can make code complex
  • Creates tight coupling
  • Harder to manage in large projects
Final Thoughts (My Advice)
When I started, I tried to learn everything at once—and got confused.

What worked for me:

  • Start with simple examples
  • Practice small programs
  • Then move to advanced concepts

Comments

Post a Comment

Popular posts from this blog

SOLID Principles – Simple Explanation for Beginners

 When I started learning object-oriented programming, I often wrote code that worked—but was hard to maintain or extend later. That’s when I came across the SOLID principles. These are five simple guidelines that help us write code that is: Easy to understand Easy to maintain Easy to scale In this blog, I’ll explain each principle in a simple way so you can understand the idea clearly. What are SOLID Principles? SOLID is a set of five design principles introduced by Robert C. Martin. Each letter represents one principle: S → Single Responsibility O → Open-Closed L → Liskov Substitution I → Interface Segregation D → Dependency Inversion S — Single Responsibility Principle (SRP) A class should have only one responsibility. Simple idea A class should do only one job. If a class has multiple responsibilities: It becomes harder to manage Changes in one part can affect other parts Example thinking Instead of: One class handling user data + logging + validation Split it into: One class fo...
Post a Comment
Read more

Single Responsibility Principle – Simple Explanation with Example

When writing code, it’s common to put multiple responsibilities inside a single file or class. It might work at first, but over time it becomes difficult to manage and update. The Single Responsibility Principle (SRP) helps solve this. It is one of the core ideas from SOLID and focuses on keeping code simple and maintainable. What is Single Responsibility Principle? The idea is simple: A class should have only one responsibility. That means: It should do one job It should have only one reason to change Why This Matters When a class does too many things: Changes become risky Bugs become harder to track Code becomes difficult to understand Keeping responsibilities separate makes your code: Cleaner Easier to maintain Easier to scale Bad Example (Multiple Responsibilities in One Class) Let’s look at a class that handles everything: class UserService { validateUser(user) { if (!user.email) { console.log...
Post a Comment
Read more