Abstraction in OOP — The Principle Explained

Abstraction is about hiding complexity and showing only what’s essential. You define what something does without specifying how.

---

The Analogy

When you use Google Maps:

• You type a destination and get directions (what)
• You don’t see the routing algorithms, satellite data processing, or server infrastructure (how)

The complexity is abstracted away behind a simple interface.

---

Abstraction in Java

Java provides two mechanisms for abstraction:

Abstract Classes

abstract class Shape {
    abstract double area();    // WHAT — every shape has an area
    // HOW — left to subclasses
}

class Circle extends Shape {
    double radius;
    double area() { return Math.PI * radius * radius; }  // HOW for circles
}

Interfaces

interface Printable {
    void print();  // WHAT — can be printed
}

class Report implements Printable {
    public void print() {
        System.out.println("Printing report...");  // HOW for reports
    }
}

---

Abstraction vs Encapsulation

These are often confused:

	Abstraction	Encapsulation
Focus	Hiding complexity	Hiding data
Level	Design level	Implementation level
Mechanism	Abstract classes, interfaces	Private fields, public methods
Question	What does it do?	How is data protected?

They work together — abstraction defines the contract; encapsulation protects the implementation.

---

Why Abstraction Matters

1. Simplicity — users interact with simple interfaces
2. Flexibility — swap implementations without changing callers
3. Focus — each layer handles its own complexity
4. Testability — program to interfaces, mock in tests

---

Summary

• Abstraction = hide the how, show the what
• Java tools: abstract classes and interface
• Different from encapsulation (data hiding)
• Enables clean architecture and flexible design

→ Full implementation in the Abstraction Deep Dive chapters.

---

What’s Next?

Foundations complete! Now let’s build real Java code — starting with Understanding Classes and Objects.