4.7. Abstraction in Java

Abstraction is the concept of hiding the complex implementation details and showing only the necessary functionality to the user.

Abstraction is fundamental in programming, especially in object-oriented programming like Java. It means that when you interact with an object, you don't need to know how it works internally. Instead, you only need to know what operations you can perform with it. For example, when you use a television remote, you don't need to understand the electronic circuits and components inside the remote; you just need to know which buttons to press to change the channel or adjust the volume.

Think of a car's dashboard. When you drive, you use the steering wheel to guide the car, the gas pedal to speed up, and the brakes to slow down. You don't concern yourself with how the engine works, how fuel is processed, or how the braking system functions. The dashboard abstracts these complex details and presents only the controls you need to operate the vehicle.

In Java, abstraction can be achieved using abstract classes and interfaces.

Java provides two primary ways to implement abstraction: abstract classes and interfaces. An abstract class can have both abstract methods (methods without a body) that subclasses must implement, as well as concrete methods (methods with a body). This allows common functionality to be reused in different subclasses. Interfaces, on the other hand, define a contract of methods that implementing classes must adhere to without providing any implementation details. This is useful for defining capabilities that can be shared across unrelated classes.

Imagine you are part of a school committee where every member has different responsibilities. The committee has a common rule book outlining the responsibilities and behavior expected from each member, but each member decides how to fulfill their duties based on their role—some may be leading events, some managing finances, and others handling communications. The rule book acts as the interface, while the individual methods of performing their roles represent the implementations in different classes.

An abstract class is a class that cannot be instantiated and may contain abstract methods (methods without a body) that must be implemented by subclasses.

abstract class Animal {
    abstract void sound();
    void sleep() {
        System.out.println("Animal is sleeping");
    }
}
class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.sound(); // Output: Dog barks
        myDog.sleep(); // Output: Animal is sleeping
    }
}

In this example, we define an abstract class called Animal. It has an abstract method sound(), which has no body and must be defined by any subclass of Animal. We also have a concrete method sleep() in the abstract class that all subclasses inherit. The Dog class extends Animal and provides the specific implementation of the sound() method. When we create an instance of Dog, we can call both the implemented method and the inherited method.

Think of an abstract blueprint for a house. While the blueprint provides structural guidelines—like the number of rooms and layouts—it does not detail the paint colors or furniture styles. Different builders can use the blueprint to create homes that fit their choices and styles. Similarly, in programming, an abstract class provides a basic structure for subclasses to implement while allowing flexibility in how they fulfill the details.

--