DEV Community

Cover image for 🔄 LIFO in Java
Mohamad mhana
Mohamad mhana

Posted on

🔄 LIFO in Java

#java #datastructures #programming #beginners

Have you ever wondered how Java remembers which method to run next?

When you call a method inside another method, Java doesn’t get confused — it uses a clever system called LIFO (Last In, First Out). Let’s break it down step by step

1️⃣ What is LIFO?

LIFO = Last In, First Out

Think of it like a stack of plates: the last plate you put on top is the first one you take off.

In Java, the method call stack works the same way.

🔗 Learn more about stack data structure in java

2️⃣ How LIFO Works in Java Methods

public class Main {
    public static void methodA() {
        System.out.println("Inside A");
        methodB();
        System.out.println("Back in A");
    }

    public static void methodB() {
        System.out.println("Inside B");
    }

    public static void main(String[] args) {
        methodA();
    }
}
Enter fullscreen mode Exit fullscreen mode

Execution Flow (Call Stack):

  1. main() is called → added to the stack

  2. methodA() is called → added on top

  3. methodB() is called → added on top

  4. methodB() finishes → removed from stack

  5. methodA() continues → removed when done

  6. main() finishes → removed last

Output:

Inside A
Inside B
Back in A
Enter fullscreen mode Exit fullscreen mode

📌 Notice how methodB ran first because it was the last one called — that’s LIFO in action.

3️⃣ Why LIFO Matters

  • Helps Java keep track of which method to return to next.
  • Explains StackOverflowError — happens when too many methods are pushed without returning.
  • Essential for understanding recursion.

🔗 Learn about the StackOverFlowError

4️⃣ Memory Tip / Analogy

  • Stack = your desk’s pile of notebooks
  • Last notebook you put on top = first one you grab
  • Visualizing it like a stack of plates or notebooks makes recursion and method calls much easier to understand.

🔗 Java Visualizer - An interactive online tool for visualizing Java code execution including call stacks:

5️⃣ LIFO in Recursion

Recursion is a perfect example of LIFO in action.

public static void countDown(int n) {
    if (n == 0) return;
    System.out.println(n);
    countDown(n - 1);
}
Enter fullscreen mode Exit fullscreen mode
  • Each recursive call is pushed onto the stack.
  • Java executes the last call first when returning.

Output for countDown(3):

3
2
1
Enter fullscreen mode Exit fullscreen mode

🔗 Recursion explained with call stack

6️⃣ StackOverflowError — When LIFO Breaks

  • Happens when too many methods are pushed onto the call stack without returning.
  • Common causes: infinite recursion or excessively deep method calls. 
public static void infinite() {
    infinite(); // will cause StackOverflowError
}
Enter fullscreen mode Exit fullscreen mode

💡 Tip: Always make sure recursive methods have exit conditions.

7️⃣ Best Practices to Work with Method Call Stack

  • Avoid deep recursion if possible.
  • Use iteration when recursion depth is too high.
  • Keep methods short and focused — easier to manage stack frames.
  • Use debuggers / stack traces to understand the flow of method calls.

🎯 Wrapping Up

Understanding LIFO in Java methods is key to writing better code, debugging effectively, and mastering recursion.

💬 Let’s hear from you:

Have you ever been confused by the order of method calls?

How do you visualize the call stack when coding?

Got a fun analogy to explain LIFO or recursion?

Drop your thoughts in the comments — I’d love to see how you picture the method stack! 🚀

Top comments (0)