Stack memory in Java - Step-by-Step Execution

Concept Flow - Stack memory

Start Program

↓

Call Method

↓

Push Method Frame on Stack

↓

Execute Method Instructions

↓

Call Another Method?

Yes→Repeat Push Frame

No↓

Method Returns

↓

Pop Method Frame from Stack

↓

Continue Previous Method

↓

Program Ends when Stack Empty

Stack memory stores method calls as frames. Each call pushes a frame; return pops it. This manages execution order.

Execution Sample

Java

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

This code calls methodA from main, which calls methodB that prints "Hello".

Execution Table

Step	Action	Stack Frames (Top to Bottom)	Output
1	Program starts, main() called	[main]
2	main() calls methodA()	[methodA, main]
3	methodA() calls methodB()	[methodB, methodA, main]
4	methodB() executes System.out.println	[methodB, methodA, main]	Hello
5	methodB() returns, frame popped	[methodA, main]
6	methodA() returns, frame popped	[main]
7	main() returns, frame popped	[]

💡 Stack is empty, program execution ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 6	Final
Stack Frames	[]	[methodA, main]	[methodB, methodA, main]	[methodA, main]	[main]	[]
Output	""	""	""	"Hello"	"Hello"	"Hello"

Key Moments - 3 Insights

Why does the stack grow when a method is called?

Each method call creates a new frame pushed on the stack to keep track of its execution context, as shown in steps 2 and 3 in the execution_table.

When does a method frame get removed from the stack?

A method frame is popped off the stack when the method finishes execution and returns, as seen in steps 5, 6, and 7.

Why is the output "Hello" printed only after methodB() executes?

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

Visual Quiz - 3 Questions

Look at the execution_table at step 3. What is the top frame on the stack?

A methodB

B main

C methodA

D System.out.println

💡 Hint

Check the 'Stack Frames' column at step 3; the top frame is the first listed.

At which step does the stack become empty?

A Step 5

B Step 6

C Step 7

D Step 4

💡 Hint

Look at the 'Stack Frames' column and find when it shows [].

If methodB() did not call System.out.println, what would change in the execution_table?

A Stack frames would not change

B No output would appear at step 4

C methodB() frame would never be pushed

D main() would be popped earlier

💡 Hint

Check the 'Output' column at step 4 to see what causes output.

Concept Snapshot

Stack memory stores method calls as frames.
Each call pushes a frame on top.
Return pops the frame off.
Top frame is the current executing method.
Stack empties when program ends.

Full Transcript

Stack memory is a special area where Java keeps track of method calls. When a method is called, a frame is pushed on the stack to hold its data. The program runs the top frame. If that method calls another, a new frame is pushed on top. When a method finishes, its frame is popped off. This way, the program knows where to return next. In the example, main calls methodA, which calls methodB. Each call adds a frame. methodB prints "Hello". Then frames pop off in reverse order until the stack is empty and the program ends.

Practice

1. What does stack memory primarily store in Java?

easy

A. Method calls and local variables

B. Objects and class variables

C. Static variables and constants

D. Files and network connections

Solution

1. Step 1: Understand stack memory role

   Stack memory stores data related to method execution like local variables and method calls.

2. Step 2: Differentiate from heap memory

   Heap stores objects, while stack stores method calls and local variables.

3. Final Answer:

   Method calls and local variables -> Option A

4. Quick Check:

   Stack memory = method calls + local variables [OK]

Hint: Stack = method calls + local variables [OK]

Common Mistakes:

• Confusing stack with heap memory
• Thinking objects are stored in stack
• Mixing static variables with stack data

2. Which of the following is the correct way to declare a local variable inside a method in Java?

easy

A. static int x = 10;

B. local int x = 10;

C. var int x = 10;

D. int x = 10;

Solution

1. Step 1: Recall local variable syntax

   Local variables inside methods are declared simply with type and name, e.g., int x = 10;

2. Step 2: Identify invalid keywords

   Keywords like 'local' or 'var int' are invalid in Java, and 'static' is not allowed for local variables.

3. Final Answer:

   int x = 10; -> Option D

4. Quick Check:

   Local variable syntax = type + name + value [OK]

Hint: Local vars: type name = value; no extra keywords [OK]

Common Mistakes:

• Using 'local' keyword which doesn't exist
• Trying to use 'static' inside methods
• Confusing 'var' usage in older Java versions

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

public class Test {
  public static void main(String[] args) {
    int a = 5;
    int b = 10;
    int c = add(a, b);
    System.out.println(c);
  }
  public static int add(int x, int y) {
    return x + y;
  }
}

medium

A. 15

B. 510

C. Compilation error

D. Runtime error

Solution

1. Step 1: Trace method calls and parameters

   Main calls add(5, 10), passing values 5 and 10 as local variables on the stack.

2. Step 2: Calculate return value

   Add method returns 5 + 10 = 15, which is stored in c and printed.

3. Final Answer:

   15 -> Option A

4. Quick Check:

   5 + 10 = 15 [OK]

Hint: Add method returns sum; print result [OK]

Common Mistakes:

• Concatenating numbers as strings
• Confusing method parameters with global variables
• Expecting runtime or compile errors

4. Identify the error in this Java code related to stack memory usage:

public class Demo {
  public static void main(String[] args) {
    int result = factorial(4);
    System.out.println(result);
  }
  public static int factorial(int n) {
    if (n == 0) return 1;
    else return n * factorial(n - 1);
  }
}

medium

A. Stack overflow due to too many local variables

B. Missing base case causing infinite recursion

C. No error, code runs correctly

D. Incorrect method return type

Solution

1. Step 1: Check recursion base case

   The factorial method has a base case: if n == 0 return 1, stopping recursion.

2. Step 2: Confirm recursion correctness

   Each recursive call reduces n by 1, so recursion ends properly without stack overflow.

3. Final Answer:

   No error, code runs correctly -> Option C

4. Quick Check:

   Base case present, recursion safe [OK]

Hint: Check for base case to avoid stack overflow [OK]

Common Mistakes:

• Assuming missing base case when it exists
• Confusing local variables with stack overflow cause
• Thinking return type is wrong

5. Consider this recursive method that calculates the sum of numbers from n down to 1:

public static int sum(int n) {
  if (n <= 0) return 0;
  else return n + sum(n - 1);
}

What will happen if you call sum(1000000) in Java, and why?

hard

A. It will return the correct sum without issues

B. It will cause a stack overflow error due to deep recursion

C. It will run infinitely without stopping

D. It will cause a compile-time error

Solution

1. Step 1: Analyze recursion depth

   Calling sum(1000000) causes 1,000,000 recursive calls, each adding a stack frame.

2. Step 2: Understand stack memory limits

   Java's stack size is limited; deep recursion like this exceeds it, causing stack overflow error.

3. Final Answer:

   It will cause a stack overflow error due to deep recursion -> Option B

4. Quick Check:

   Deep recursion > stack size = stack overflow [OK]

Hint: Very deep recursion causes stack overflow error [OK]

Common Mistakes:

• Assuming recursion always works regardless of depth
• Thinking it runs infinitely without base case
• Confusing runtime errors with compile errors