Why Abstract methods in Java? - Purpose & Use Cases

The Big Idea

What if you could write a rule once and force everyone to follow it perfectly without repeating yourself?

The Scenario

Imagine you are building a program with many different types of animals. Each animal can make a sound, but the sounds are all different. If you try to write separate code for each animal's sound everywhere, it becomes messy and hard to manage.

The Problem

Writing separate code for each animal's sound everywhere means repeating yourself a lot. It is easy to forget to add a sound for a new animal or make mistakes. Changing one animal's sound means hunting through many places in your code, which is slow and error-prone.

The Solution

Abstract methods let you define a general rule that all animals must have a sound, but you don't say what the sound is. Each animal then provides its own sound. This keeps your code clean and organized, and makes adding new animals easy and safe.

Before vs After

✗ Before

class Animal {
  void makeSound() {
    // no general rule, each animal repeats code
  }
}

class Dog extends Animal {
  void makeSound() {
    System.out.println("Bark");
  }
}

class Cat extends Animal {
  void makeSound() {
    System.out.println("Meow");
  }
}

✓ After

abstract class Animal {
  abstract void makeSound();
}

class Dog extends Animal {
  @Override
  void makeSound() {
    System.out.println("Bark");
  }
}

class Cat extends Animal {
  @Override
  void makeSound() {
    System.out.println("Meow");
  }
}

What It Enables

Abstract methods enable you to create clear, reusable blueprints that force subclasses to provide their own specific behavior, making your code easier to maintain and extend.

Real Life Example

Think of a remote control that works with many devices. The remote defines buttons like "power" or "volume" as abstract actions. Each device (TV, stereo) implements these actions differently, but the remote can control all devices using the same buttons.

Key Takeaways

Abstract methods define a method without a body, forcing subclasses to implement it.

This helps organize code by setting clear rules for subclasses.

It makes adding new types easier and safer without changing existing code.