Abstraction

Introduction

In the previous lessons, you learned about Encapsulation, Inheritance, and Polymorphism. Together, these concepts help build reusable and maintainable software.

However, imagine you're designing an online payment system.

Users only need to know:

• Enter the amount
• Choose a payment method
• Click Pay

They do not need to know:

• How the payment gateway encrypts data
• How the bank verifies the transaction
• How the server communicates with third-party APIs
• How the database stores transaction records

The internal implementation is hidden from the user.

This concept is called Abstraction.

Abstraction is one of the four fundamental pillars of Object-Oriented Programming (OOP).

It focuses on hiding implementation details and exposing only the essential functionality.

Java provides abstraction through:

• Abstract Classes
• Interfaces

Abstraction is widely used in:

• Spring Boot
• Hibernate
• JDBC
• Java Collections Framework
• Microservices
• REST APIs
• Design Patterns
• Enterprise Applications

In this lesson, you'll learn:

• What is Abstraction?
• Why Abstraction is Important
• Abstract Classes
• Abstract Methods
• Concrete Methods
• Interfaces
• Default Methods
• Static Interface Methods
• Functional Interfaces
• Multiple Inheritance using Interfaces
• Dependency Injection Concepts
• Real-world Examples
• Best Practices
• Common Mistakes
• Hands-on Exercises
• Professional Interview Questions

What is Abstraction?

Abstraction is the process of hiding implementation details and exposing only the necessary functionality.

Example:

Driving a car.

The driver uses:

• Steering Wheel
• Brake
• Accelerator
• Gear

The driver does not need to understand:

• Engine combustion
• Fuel injection
• Transmission mechanics

Only the essential controls are visible.

Similarly, in Java:

User

↓

Interface

↓

Hidden Implementation

Why Abstraction?

Without abstraction:

Payment payment = new Payment();

payment.connectBank();
payment.encrypt();
payment.verifyOTP();
payment.updateDatabase();
payment.generateReceipt();

With abstraction:

payment.pay();

Benefits:

• Hides complexity
• Reduces coupling
• Easier maintenance
• Better security
• Improved flexibility
• Easier testing

Abstract Class

An abstract class is a class that cannot be instantiated directly.

Example:

abstract class Animal {

}

This is invalid:

Animal animal = new Animal();

Compilation Error.

An abstract class is designed to be extended.

Abstract Methods

An abstract method has no implementation.

Example:

abstract class Animal {

    abstract void sound();

}

The child class must provide the implementation.

Implementing Abstract Methods

abstract class Animal {

    abstract void sound();

}

class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("Dog Barks");
    }

}

Using it:

Animal animal = new Dog();

animal.sound();

Output:

Dog Barks

Concrete Methods

Abstract classes can also contain fully implemented methods.

Example:

abstract class Animal {

    void eat() {
        System.out.println("Eating...");
    }

    abstract void sound();

}

Child classes inherit the concrete method while implementing the abstract one.

When Should You Use an Abstract Class?

Use an abstract class when:

• Multiple classes share common code.
• Some methods have identical implementations.
• Other methods require different implementations.
• You want to provide shared state (fields).

Example:

Vehicle

↓

Car

Bus

Truck

What is an Interface?

An interface defines a contract that classes agree to implement.

Example:

interface Payment {

    void pay();

}

Implementing:

class UpiPayment implements Payment {

    @Override
    public void pay() {
        System.out.println("UPI Payment");
    }

}

Using:

Payment payment = new UpiPayment();

payment.pay();

Output:

UPI Payment

Abstract Class vs Interface

Default Methods (Java 8+)

Interfaces can provide default implementations.

interface Vehicle {

    default void start() {
        System.out.println("Vehicle Started");
    }

}

The implementing class may use or override this behavior.

Static Methods in Interfaces

interface Calculator {

    static int square(int number) {
        return number * number;
    }

}

Calling:

System.out.println(Calculator.square(5));

Output:

25

Functional Interfaces

A Functional Interface contains exactly one abstract method.

Example:

@FunctionalInterface
interface Greeting {

    void sayHello();

}

Functional interfaces are the foundation of:

• Lambda Expressions
• Streams API
• Method References

Common examples:

• Runnable
• Callable
• Comparator
• Predicate
• Function
• Consumer
• Supplier

Multiple Inheritance Using Interfaces

Java does not allow multiple inheritance with classes.

However:

interface Printer {

    void print();

}

interface Scanner {

    void scan();

}

class MultiFunctionPrinter implements Printer, Scanner {

    public void print() {
        System.out.println("Printing...");
    }

    public void scan() {
        System.out.println("Scanning...");
    }

}

This avoids the Diamond Problem associated with multiple inheritance of classes.

Dependency Injection Concept

One of the biggest advantages of abstraction is Dependency Injection.

Example:

interface NotificationService {

    void send(String message);

}

Implementations:

class EmailService implements NotificationService {

    public void send(String message) {
        System.out.println("Sending Email: " + message);
    }

}

class SmsService implements NotificationService {

    public void send(String message) {
        System.out.println("Sending SMS: " + message);
    }

}

Using abstraction:

NotificationService service = new EmailService();

service.send("Welcome!");

Changing to SMS requires only:

service = new SmsService();

The client code remains unchanged.

This principle is heavily used by the Spring Framework.

Real-World Example: Banking Application

abstract class Account {

    abstract double calculateInterest(double balance);

}

Implementations:

class SavingsAccount extends Account {

    @Override
    double calculateInterest(double balance) {
        return balance * 0.05;
    }

}

class CurrentAccount extends Account {

    @Override
    double calculateInterest(double balance) {
        return 0;
    }

}

Real-World Example: Payment Gateway

interface PaymentGateway {

    void processPayment(double amount);

}

Implementations:

• RazorpayPayment
• StripePayment
• PayPalPayment

Each class provides its own implementation while exposing the same contract.

Memory Representation

Payment payment = new UpiPayment();

Memory:

Stack

payment

↓

Heap

+---------------------------+
| UpiPayment Object         |
+---------------------------+

Reference Type:

Payment

Actual Object:

UpiPayment

The actual implementation is selected at runtime.

Best Practices

Program to Interfaces

Prefer:

List<String> names = new ArrayList<>();

Instead of:

ArrayList<String> names = new ArrayList<>();

Use Abstract Classes for Shared State

If multiple classes share fields and common implementations, use an abstract class.

Use Interfaces for Contracts

Interfaces define capabilities that unrelated classes can implement.

Keep Interfaces Focused

Follow the Interface Segregation Principle (ISP) by designing small, purpose-specific interfaces.

Favor Composition with Abstraction

Use interfaces to reduce coupling and improve testability.

Common Mistakes

Creating Large Interfaces

Large interfaces force implementing classes to define methods they may not need.

Using Abstract Classes When No Shared Code Exists

If only behavior needs to be defined, an interface is often a better choice.

Forgetting to Implement Abstract Methods

A non-abstract subclass must implement all inherited abstract methods.

Confusing Abstraction with Encapsulation

• Abstraction hides implementation details.
• Encapsulation protects internal data.

Depending on Concrete Classes

Coding against concrete implementations reduces flexibility.

Hands-on Exercise

Create a Java program that:

1. Creates an abstract class Employee with:
   • Fields: name, employeeId
   • Concrete method: displayInfo()
   • Abstract method: calculateSalary()
2. Creates FullTimeEmployee and ContractEmployee classes that extend Employee.
3. Creates a NotificationService interface.
4. Implements it using EmailNotification and SmsNotification.
5. Demonstrates runtime polymorphism using interface references.
6. Adds a default method to the interface.
7. Uses a functional interface with a lambda expression to print a welcome message.

Summary

Abstraction simplifies complex systems by exposing only essential functionality while hiding implementation details. Java supports abstraction using abstract classes and interfaces. Abstract classes are useful when sharing common state and behavior, whereas interfaces define contracts that enable loose coupling, multiple inheritance of type, and highly extensible enterprise applications.

Key Takeaways

• Abstraction hides implementation details and exposes essential functionality.
• Abstract classes cannot be instantiated.
• Abstract methods must be implemented by concrete subclasses.
• Interfaces define contracts for implementing classes.
• Interfaces support multiple inheritance of type.
• Default and static methods enhance interface capabilities.
• Functional interfaces enable lambda expressions.
• Programming to interfaces improves flexibility and maintainability.
• Abstraction is the foundation of Dependency Injection in frameworks like Spring.

Professional Interview Questions