Skip to main content

Abstraction in Java

When I started learning Java, abstraction felt confusing at first. But once I connected it with real-life examples, it started to make sense.

In this blog, I’ll explain abstraction in the simplest way possible—just like how I understood it.


What is Abstraction?

Abstraction means hiding the internal implementation details and showing only the essential functionality.

In my own words:

I focus on what something does, not how it does it.

This idea is actually everywhere in real life.

Real-Life Example (How I Understood It)

Think about a car:

  • I use the steering, brake, and accelerator
  • But I don’t know how the engine works internally

Still, I can drive the car perfectly.

That’s abstraction.

Why Abstraction is Important

When I started building projects, I realized abstraction helps me:

  • Reduce complexity
  • Write cleaner code
  • Hide sensitive logic
  • Make code reusable
  • Easily maintain large applications

How Abstraction is Achieved in Java

In Java, I mainly use two ways:

  • Abstract Classes
  • Interfaces

1. Abstract Class in Java

An abstract class is a class that I cannot create objects from directly. It can have both:

  • Abstract methods (no body)
  • Normal methods (with body)

Example

abstract class Vehicle {
    abstract void start();

    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {
    void start() {
        System.out.println("Car starts with key");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle v = new Car();
        v.start();
        v.stop();
    }
}

My Understanding

  • I define a general idea in Vehicle
  • Then provide actual behavior in Car
  • I can’t create Vehicle directly

2. Interface in Java

An interface is like a blueprint. It only defines methods, and I must implement them in another class.

Example


interface Payment {
    void pay();
}

class UPI implements Payment {
    public void pay() {
        System.out.println("Payment via UPI");
    }
}

class Card implements Payment {
    public void pay() {
        System.out.println("Payment via Card");
    }
}

public class Main {
    public static void main(String[] args) {
        Payment p1 = new UPI();
        p1.pay();

        Payment p2 = new Card();
        p2.pay();
    }
}

My Understanding

  • Same method pay()
  • Different implementations (UPI, Card)
  • Very flexible and reusable

Abstract Class vs Interface (Simple View)

Feature Abstract Class Interface
Methods Can have both abstract and normal methods Mostly contains abstract methods
Implementation Can provide method implementation Only method declaration (implementation in class)
Inheritance A class can extend only one abstract class A class can implement multiple interfaces
Usage Used when classes share common behavior Used for defining a common contract
Object Creation Cannot create object directly Cannot create object directly

Real Use Cases (Where I See This in Projects)

  • Payment systems → Same method, different payment types
  • Banking apps → Deposit/withdraw without knowing backend logic
  • APIs → Only necessary data is exposed
  • Frontend apps → Button click hides backend operations

Abstraction vs Encapsulation

I used to mix these up a lot:

  • Abstraction → Hides implementation
  • Encapsulation → Hides data

👉 Abstraction = Design
👉 Encapsulation = Security

Conclusion

Once I understood abstraction, I stopped worrying about internal complexity and started focusing on clean design.

If you’re a beginner, just remember:

Show only what is needed, hide everything else.

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

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 Chil...
Post a Comment
Read more