Abstraction in Java

Analogy categoryAnalogies

1. Introduction

Abstraction is the OOP principle of hiding complex implementation details and exposing only the essential features of an object. It lets programmers focus on 'what' an object does rather than 'how' it does it. In Java, abstraction is primarily achieved through two mechanisms: abstract classes and interfaces.

🏏

Cricket analogy: Abstraction is like a captain only needing to know a bowler can "deliver a wicket-taking ball" (what) without tracking the exact wrist-seam mechanics (how), achieved in Java via abstract Bowler classes and Fieldable interfaces.

An abstract class can provide partial implementation — a mix of fully implemented (concrete) methods and abstract (unimplemented) methods that subclasses must override. An interface, by contrast, traditionally defines a pure contract of method signatures that implementing classes must fulfill (interfaces are covered in depth in the OOP Advanced module).

🏏

Cricket analogy: An abstract "Bowler" class might implement runUp() concretely while leaving delivery() abstract, whereas a "Fieldable" interface just demands catch() and throw() signatures without saying how any team executes them.

2. Syntax

java

// Abstract class
abstract class Shape {
    abstract double area();       // abstract method - no body

    void describe() {             // concrete method - has a body
        System.out.println("This is a shape with area: " + area());
    }
}

class Circle extends Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

3. Explanation

An abstract class is declared using the abstract keyword and cannot be instantiated directly with new — attempting new Shape() would cause a compile-time error. It can, however, declare constructors (called via subclass constructors through implicit or explicit super()), instance fields, concrete methods with full implementations, and abstract methods that have no body and must be implemented by any concrete (non-abstract) subclass.

🏏

Cricket analogy: Writing new Bowler() directly is like fielding a generic, unnamed bowler in a match scorecard - Java refuses it at compile time, though Bowler can still declare a runUp field and a constructor called via Pacer's super().

If a subclass does not implement all inherited abstract methods, that subclass must itself be declared abstract. Interfaces provide another route to abstraction: a class implements an interface using the implements keyword, promising to provide concrete bodies for all of the interface's abstract methods. Together, abstract classes and interfaces let API designers define 'what' operations must exist without necessarily dictating 'how' every one of them is implemented.

🏏

Cricket analogy: If Wicketkeeper extends abstract Fielder but skips catch(), it must itself be declared abstract; meanwhile a class implements the Stumper interface with implements, promising to define stump() so selectors know 'what' every keeper must do without dictating 'how'.

Exam trap: An abstract class CAN have a constructor and concrete (fully implemented) methods — it is not required to have all methods abstract. What makes it abstract is that it cannot be instantiated directly, and it may contain zero or more abstract methods.

Quick contrast: abstract classes can mix abstract and concrete methods and support single inheritance; interfaces traditionally define contracts and support multiple inheritance of type. Full interface rules are covered in the dedicated interfaces-in-java lesson.

4. Example

java

abstract class Employee {
    String name;

    Employee(String name) {
        this.name = name;
    }

    abstract double calculateSalary(); // abstract method

    void printPayslip() {              // concrete method
        System.out.println(name + "'s salary: " + calculateSalary());
    }
}

class FullTimeEmployee extends Employee {
    double monthlySalary;

    FullTimeEmployee(String name, double monthlySalary) {
        super(name);
        this.monthlySalary = monthlySalary;
    }

    @Override
    double calculateSalary() {
        return monthlySalary;
    }
}

class Demo {
    public static void main(String[] args) {
        // Employee e = new Employee("X"); // compile error - cannot instantiate abstract class
        Employee emp = new FullTimeEmployee("Kiran", 60000);
        emp.printPayslip();
    }
}

5. Output

text

Kiran's salary: 60000.0

6. Key Takeaways

Abstraction hides implementation details and exposes only essential behavior.
Abstract classes can mix abstract methods (no body) with concrete methods (full implementation).
An abstract class cannot be instantiated directly, even if it has concrete methods and a constructor.
A concrete subclass must implement all inherited abstract methods, or it must also be declared abstract.
Interfaces are another abstraction mechanism in Java, defining a contract of methods to be implemented.