Call stack behavior in Java - Step-by-Step Execution

Concept Flow - Call stack behavior

Program starts

↓

Call main()

↓

Call function A

↓

Call function B

↓

Function B returns

↓

Function A returns

↓

main() returns

↓

Program ends

The program starts by calling main(), which may call other functions. Each call adds a frame to the stack. When a function finishes, its frame is removed, returning control to the caller.

Execution Sample

Java

public class Demo {
  public static void main(String[] args) {
    greet();
  }
  static void greet() {
    sayHello();
  }
  static void sayHello() {
    System.out.println("Hello!");
  }
}

This Java program calls main(), which calls greet(), which calls sayHello() that prints "Hello!".

Execution Table

Step	Action	Call Stack (Top to Bottom)	Output
1	Program starts, main() called	main()
2	main() calls greet()	greet() -> main()
3	greet() calls sayHello()	sayHello() -> greet() -> main()
4	sayHello() executes System.out.println	sayHello() -> greet() -> main()	Hello!
5	sayHello() returns	greet() -> main()
6	greet() returns	main()
7	main() returns

💡 All functions returned, call stack is empty, program ends.

Variable Tracker

Call Stack	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
Stack Frames	empty	main()	greet() -> main()	sayHello() -> greet() -> main()	sayHello() -> greet() -> main()	greet() -> main()	main()	empty

Key Moments - 3 Insights

Why does the call stack grow when a function is called?

Each function call creates a new frame on the stack to keep track of where to return and local variables, as shown in steps 2 and 3 of the execution_table.

When does a function frame get removed from the call stack?

A function frame is removed when the function finishes execution and returns, as seen in steps 5, 6, and 7 where frames disappear from the stack.

Why is the output "Hello!" printed only after sayHello() is called?

The output happens inside sayHello(), which is on top of the stack at step 4, so the print executes only when sayHello() runs.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the top frame on the call stack?

A sayHello()

B greet()

C main()

D No frames

💡 Hint

Check the 'Call Stack' column at step 3 in the execution_table.

At which step does the call stack become empty?

A Step 5

B Step 3

C Step 7

D Step 1

💡 Hint

Look at the 'Call Stack' column and find when it shows empty.

If greet() did not call sayHello(), what would be the call stack at step 3?

A sayHello() -> greet() -> main()

B greet() -> main()

C main() only

D empty

💡 Hint

Refer to the call stack changes in the execution_table and imagine skipping sayHello() call.

Concept Snapshot

Call stack stores active function calls.
Each call adds a frame on top.
Return removes the top frame.
Top frame is the current running function.
Stack empty means program finished.

Full Transcript

This visual shows how Java manages function calls using the call stack. When the program starts, main() is called and added to the stack. main() calls greet(), which adds greet() on top. greet() calls sayHello(), adding sayHello() on top. When sayHello() runs, it prints "Hello!". After sayHello() finishes, its frame is removed, returning control to greet(). Then greet() returns, removing its frame, and finally main() returns, emptying the stack and ending the program. This step-by-step trace helps understand how the call stack grows and shrinks with function calls and returns.

Practice

1. What does the call stack do in Java when a method is called?

easy

A. It adds a new frame for the method call on top of the stack.

B. It removes all previous method calls from memory.

C. It immediately executes all methods in the program.

D. It stores variables permanently for the entire program.

Solution

1. Step 1: Understand call stack basics

   The call stack keeps track of active method calls by adding a frame for each call.

2. Step 2: What happens on method call

   When a method is called, a new frame is pushed on top of the stack to hold its execution context.

3. Final Answer:

   It adds a new frame for the method call on top of the stack. -> Option A

4. Quick Check:

   Call stack adds frames on method calls [OK]

Hint: Call stack adds frames on method calls, removes on return [OK]

Common Mistakes:

• Thinking call stack removes all frames on each call
• Believing variables are stored permanently in call stack
• Confusing call stack with heap memory

2. Which of the following is the correct way to call a method named processData in Java?

easy

A. run processData();

B. call processData();

C. processData();

D. execute processData();

Solution

1. Step 1: Recall Java method call syntax

   In Java, methods are called by writing the method name followed by parentheses, e.g., processData();.

2. Step 2: Check each option

   Only processData(); uses the correct syntax without extra keywords.

3. Final Answer:

   processData(); -> Option C

4. Quick Check:

   Method call syntax = methodName() [OK]

Hint: Method calls use methodName() syntax without extra words [OK]

Common Mistakes:

• Adding keywords like 'call' or 'run' before method name
• Missing parentheses after method name
• Using incorrect keywords not in Java syntax

3. What will be the output of the following Java code?

public class Test {
    public static void main(String[] args) {
        first();
    }
    static void first() {
        System.out.print("A");
        second();
        System.out.print("B");
    }
    static void second() {
        System.out.print("C");
    }
}

medium

A. CAB

B. ABC

C. BAC

D. ACB

Solution

1. Step 1: Trace method calls and prints

   Main calls first(), which prints "A", then calls second() that prints "C".

2. Step 2: Return to first() and print remaining output

   After second() finishes, first() prints "B".

3. Final Answer:

   ACB -> Option D

4. Quick Check:

   Print order = A, C, B [OK]

Hint: Follow call order and prints step-by-step [OK]

Common Mistakes:

• Ignoring that second() prints before first() resumes
• Assuming prints happen after all calls finish
• Mixing print order of method calls

4. Identify the error in this Java code related to call stack behavior:

public class Demo {
    public static void main(String[] args) {
        methodA();
    }
    static void methodA() {
        methodB();
    }
    static void methodB() {
        methodA();
    }
}

medium

A. Infinite recursion causing stack overflow error.

B. Syntax error due to missing return statements.

C. methodB() is never called.

D. No error; code runs normally.

Solution

1. Step 1: Analyze method calls

   methodA() calls methodB(), which calls methodA() again, creating a loop.

2. Step 2: Understand call stack effect

   This causes infinite recursion, adding frames endlessly until stack overflow occurs.

3. Final Answer:

   Infinite recursion causing stack overflow error. -> Option A

4. Quick Check:

   Recursive calls without base case cause stack overflow [OK]

Hint: Look for recursive calls without stopping condition [OK]

Common Mistakes:

• Thinking missing return causes syntax error
• Assuming code runs without error
• Missing the infinite recursion loop

5. Given this Java code, what is the final output?

public class StackTest {
    public static void main(String[] args) {
        System.out.print(factorial(3));
    }
    static int factorial(int n) {
        if (n == 0) return 1;
        return n * factorial(n - 1);
    }
}

Consider how the call stack behaves during recursion.

hard

A. 9

B. 6

C. 3

D. 1

Solution

1. Step 1: Understand factorial recursion

   factorial(3) calls factorial(2), factorial(1), factorial(0), then returns 1.

2. Step 2: Calculate return values on stack unwind

   factorial(1) = 1 * 1 = 1, factorial(2) = 2 * 1 = 2, factorial(3) = 3 * 2 = 6.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   3! = 6 by recursive multiplication [OK]

Hint: Multiply down from base case as stack unwinds [OK]

Common Mistakes:

• Confusing base case return value
• Multiplying before recursive call returns
• Misunderstanding recursion order