DEV Community: Buddika Abeykoon

Method Calling Stack in Java

Buddika Abeykoon — Mon, 25 May 2026 03:53:41 +0000

class MethodCallingStack{
    public static void MyMethod(){
        System.out.println("Start MyMethod()");
        int x;
        x=200;
        System.out.println("End MyMethod()");
    }

    public static void main(String args[]){
        System.out.println("Start main()");
        int x;
        x=100;
        System.out.println("End main()");
    }
}

What is the Stack memory?

Stack memory is a temporary memory area used to store method calls and local variables. Every time a method runs, Java creates a stack frame for that method. Variables like int x = 100; are stored in stack memory. When the method finishes, its data is removed automatically from the stack.

What is the Heap Memory?

Heap memory is used to store objects and arrays created using the new keyword. Heap memory is shared by all methods in the program. For example, in Student s = new Student();, the object is stored in heap memory, while the reference variable s is stored in stack memory. Heap memory keeps objects until they are removed by Java’s Garbage Collector.

Working of Method Calling Stack!

This program explains how the method calling stack works in Java. When the program starts, the main() method is loaded into stack memory, and the local variable x = 100 is stored inside the main() stack frame. If MyMethod() is called, a new stack frame is created above the main() frame, and its local variable x = 200 is stored there. Each method has its own separate variables in the stack memory. When a method finishes, its stack frame is removed automatically. This program does not create any objects, so heap memory is not used here.

Recursive Factorial Program in Java

Buddika Abeykoon — Mon, 18 May 2026 17:23:52 +0000

public class RecursiveFactorial {
    static int factorial(int n) {
        if (n == 0 || n == 1) {
            return 1; // Base case
        } else {
            return n * factorial(n - 1); // Recursive call
        }
    }

    public static void main(String[] args) {
        int number = 5;

        int result = factorial(number);

        System.out.println("Factorial of " + number + " is: " + result);
    }
}

This program is used to calculate the factorial of a number using recursion in Java. Recursion means a method calls itself repeatedly until a stopping condition is reached. In this program, the factorial() method checks whether the number is 0 or 1. If it is, the method returns 1, because the factorial of 0 and 1 is always 1. This is called the base case and it stops the recursion. If the number is greater than 1, the method multiplies the number by the factorial of the previous number using factorial(n - 1). For example, when the number is 5, the calculation happens as follows,
5!=5×4×3×2×1=120
In the main method, the number 5 is stored in a variable, the factorial() method is called, and the final answer is printed on the screen. The output of the program is “Factorial of 5 is: 120”.

Reason Why j is Always 0 in the Output

Buddika Abeykoon — Tue, 12 May 2026 02:49:05 +0000

public class Main
{
public static void main(String[] args) {
System.out.println("Start\n");
int k=0;
System.out.println("k i j");
for(int i=0; i<10; i++) {
int j=0;
System.out.println(k+" "+i+" "+j);
j++;k++;
}
System.out.println("\n\nEnd");
}

}

Start
k i j
0 0 0
1 1 0
2 2 0
3 3 0
4 4 0
5 5 0
6 6 0
7 7 0
8 8 0
9 9 0
End

j is always printed as 0 because it is declared inside the for loop. Every time the loop runs, a new variable j is created and its value starts again from 0. After printing, j increases by 1 using j++, but when the next loop iteration starts, j is reset back to 0. That is why the output always shows 0 for j.

Why This Java Loop Is Not Infinite 🤔

Buddika Abeykoon — Mon, 11 May 2026 05:31:35 +0000

public class Main
{
public static void main(String[] args) {
System.out.println("Start\n");
byte i;
for(i=0; i<10; i--) {
System.out.print(i+", ");
}
System.out.print("\b\b");
System.out.println("\n\n\"i\" value is "+i+"\n\nEnd");

}

Start

0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, -32, -33, -34, -35, -36, -37, -38, -39, -40, -41, -42, -43, -44, -45, -46, -47, -48, -49, -50, -51, -52, -53, -54, -55, -56, -57, -58, -59, -60, -61, -62, -63, -64, -65, -66, -67, -68, -69, -70, -71, -72, -73, -74, -75, -76, -77, -78, -79, -80, -81, -82, -83, -84, -85, -86, -87, -88, -89, -90, -91, -92, -93, -94, -95, -96, -97, -98, -99, -100, -101, -102, -103, -104, -105, -106, -107, -108, -109, -110, -111, -112, -113, -114, -115, -116, -117, -118, -119, -120, -121, -122, -123, -124, -125, -126, -127, -128,

"i" value is 127

End

This loop may look like an infinite loop because the value of i keeps decreasing and will always seem to be less than 10. However, the variable i is declared as a byte, and in Java a byte can only store values from -128 to 127. The loop starts from 0 and keeps decrementing until it reaches -128. After that, Java cannot store -129 in a byte, so the value automatically wraps around to 127 due to overflow. Once i becomes 127, the condition i < 10 becomes false, and the loop terminates. That’s why this loop is not infinite.

Why Float and Double Outputs Are Different?

Buddika Abeykoon — Fri, 08 May 2026 08:59:06 +0000

float f = Long.MAX_VALUE;
double d = Long.MAX_VALUE;

System.out.println("Float max value is : "+ f);
System.out.println("Double max value is : "+ d);

===============================================
Float max value is : 9.223372E18
Double max value is : 9.223372036854776E18
===============================================*/

When we assign Long.MAX_VALUE to float and double, both try to store a very large number. But float cannot keep many digits accurately, so Java rounds the value and shows a shorter number like 9.223372E18. double has higher precision, so it can store more digits and shows a more accurate value like 9.223372036854776E18. That’s why both outputs are different even though they come from the same value.