Abstract classes in Java - Step-by-Step Execution

Concept Flow - Abstract classes

Define abstract class

↓

Declare abstract method(s)?

Yes→No method body

↓

Provide concrete method(s)

↓

Create subclass

↓

Implement abstract method(s)

↓

Instantiate subclass object

↓

Use methods (abstract implemented + concrete)

An abstract class defines methods without full code, subclasses must complete them before creating objects.

Execution Sample

Java

abstract class Animal {
    abstract void sound();
    void breathe() {
        System.out.println("Breathing...");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound();
        d.breathe();
    }
}

Defines an abstract Animal class with an abstract sound method and a concrete breathe method; Dog class implements sound; then Dog object calls both methods.

Execution Table

Step	Action	Evaluation	Result
1	Define abstract class Animal with abstract method sound()	Animal cannot be instantiated	Animal is a blueprint with abstract method sound()
2	Define concrete method breathe() in Animal	Method breathe() has implementation	breathe() prints 'Breathing...' when called
3	Create subclass Dog extends Animal	Dog inherits Animal's methods	Dog must implement abstract method sound()
4	Implement sound() in Dog	sound() prints 'Bark'	Dog now concrete, can be instantiated
5	Instantiate Dog d = new Dog()	Object d created	d is a Dog object
6	Call d.sound()	Calls Dog's sound()	Output: Bark
7	Call d.breathe()	Calls Animal's breathe()	Output: Breathing...
8	Try to instantiate Animal (not shown)	Compilation error	Cannot instantiate abstract class Animal

💡 Execution stops after Dog object calls methods; Animal cannot be instantiated directly.

Variable Tracker

Variable	Start	After Step 5	After Step 6	After Step 7	Final
d	null	Dog object created	Method sound() called	Method breathe() called	Dog object with methods used

Key Moments - 3 Insights

Why can't we create an object of the abstract class Animal?

Because Animal has an abstract method sound() without implementation, Java prevents creating objects from incomplete classes (see execution_table step 1 and 8).

How does Dog class use the breathe() method without defining it?

Dog inherits breathe() from Animal, which has a concrete implementation, so Dog objects can use it directly (see execution_table step 7).

What happens if Dog does not implement the abstract method sound()?

Dog would also become abstract and cannot be instantiated, so Java requires Dog to implement sound() to create objects (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is printed when d.sound() is called at step 6?

A "Breathing..."

B "Bark"

C Nothing, it causes an error

D "sound() method called"

💡 Hint

Check execution_table row for step 6 where d.sound() is called and output is shown.

At which step does the Dog class become concrete and instantiable?

A Step 4

B Step 5

C Step 3

D Step 1

💡 Hint

Look at execution_table step 4 where Dog implements sound(), making it concrete.

If we try to create new Animal(), what happens according to the execution table?

A Runtime error occurs

B Object is created successfully

C Compilation error: Cannot instantiate abstract class

D Animal's sound() method is called

💡 Hint

See execution_table step 8 about instantiating Animal.

Concept Snapshot

abstract class ClassName {
  abstract void methodName(); // no body
  void concreteMethod() { ... } // optional
}

- Abstract classes cannot be instantiated.
- Subclasses must implement all abstract methods.
- Can have concrete methods usable by subclasses.
- Used to define a common template with some methods left to subclasses.

Full Transcript

An abstract class in Java is a class that cannot be instantiated directly because it may contain abstract methods without implementation. It acts as a blueprint for other classes. Abstract methods are declared without a body and must be implemented by subclasses. Concrete methods in the abstract class can be used by subclasses as is. In the example, Animal is abstract with an abstract method sound() and a concrete method breathe(). Dog extends Animal and implements sound(), making Dog concrete and instantiable. The Dog object can call both sound() and breathe(). Trying to instantiate Animal directly causes a compilation error. This structure helps organize code by defining common behavior and forcing subclasses to provide specific implementations.