Call stack behavior in Java - Mini Project: Build & Apply

Call Stack Behavior

📖 Scenario: Imagine you are baking a layered cake. Each layer depends on the previous one being ready. In programming, functions work similarly using a call stack to keep track of which function is running and what to do next.

🎯 Goal: You will write a simple Java program with three functions calling each other. You will observe how the call stack works by printing messages when entering and exiting each function.

📋 What You'll Learn

Create three functions named first(), second(), and third().

Each function should print a message when it starts and when it ends.

The first() function calls second(), and second() calls third().

Call first() from the main method to start the chain.

💡 Why This Matters

🌍 Real World

Understanding call stack behavior helps when programs call many functions, like in games or apps with multiple features.

💼 Career

Software developers use call stack knowledge to debug errors and optimize program flow.

1

Create the first() function

Write a public static void function called first() that prints "Entering first" when it starts and "Exiting first" when it ends.

Java

public class CallStackDemo {
    public static void main(String[] args) {
        // Your code here
    }

    // Create the first() function below
    // Your code here
}

Hint

Define the first() method inside the CallStackDemo class. Use System.out.println to print messages.

2

Create the second() function and call it from first()

Write a public static void function called second() that prints "Entering second" and "Exiting second". Then, modify first() to call second() between its print statements.

Java

public class CallStackDemo {
    public static void main(String[] args) {
        // Your code here
    }

    public static void first() {
        System.out.println("Entering first");
        // Call second() here
        // Your code here
        System.out.println("Exiting first");
    }

    // Create the second() function below
    // Your code here
}

Hint

Define second() like first(). Inside first(), call second() between the print statements.

3

Create the third() function and call it from second()

Write a public static void function called third() that prints "Entering third" and "Exiting third". Then, modify second() to call third() between its print statements.

Java

public class CallStackDemo {
    public static void main(String[] args) {
        // Your code here
    }

    public static void first() {
        System.out.println("Entering first");
        second();
        System.out.println("Exiting first");
    }

    public static void second() {
        System.out.println("Entering second");
        // Call third() here
        // Your code here
        System.out.println("Exiting second");
    }

    // Create the third() function below
    // Your code here
}

Hint

Define third() like the others. Call third() inside second() between the print statements.

4

Call first() from main() and print the output

In the main method, call the first() function. Run the program to see the order of messages printed, showing how the call stack works.

Java

public class CallStackDemo {
    public static void main(String[] args) {
        // Call first() here
        // Your code here
    }

    public static void first() {
        System.out.println("Entering first");
        second();
        System.out.println("Exiting first");
    }

    public static void second() {
        System.out.println("Entering second");
        third();
        System.out.println("Exiting second");
    }

    public static void third() {
        System.out.println("Entering third");
        System.out.println("Exiting third");
    }
}

Hint

Call first() inside main() to start the chain of function calls.

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