Factorial using Recursion in Java

What is recursion

Recursion is when a method calls itself to solve a smaller version of a problem. Factorial is the classic example, because n! can be written in terms of (n-1)!. Every recursion needs a base case — a simple situation that stops it.

Factorial as recursion

Factorial has a naturally recursive definition:

5! = 5 × 4!
4! = 4 × 3!
...
0! = 1   (the base case)

Each factorial is defined using a smaller factorial, all the way down to 0! = 1. That structure maps directly onto a recursive method.

The Java program

public class Factorial {
    static int factorial(int n) {
        if (n == 0)              // base case
            return 1;
        return n * factorial(n - 1);   // recursive call
    }
    public static void main(String[] args) {
        System.out.println(factorial(5));
    }
}

The method returns 1 when n is 0 (base case), otherwise it returns n times the factorial of n-1. Each call reduces n until it reaches 0.

Dry run

The base case matters

// WRONG: no base case -> infinite recursion
static int bad(int n) {
    return n * bad(n - 1);   // never stops -> StackOverflowError
}

Without a base case, the method calls itself forever, filling the call stack until Java throws a StackOverflowError. Every recursion must have a stopping condition.

Loop vs recursion

• Recursion — elegant, mirrors the maths, but uses call stack memory.
• Loop — more efficient, no deep stack, better for large n.

Both give the same answer. Learn recursion for understanding; use a loop when performance matters.

Common mistakes

• Missing base case. Causes infinite recursion and a StackOverflowError.
• Wrong base case value. 0! = 1, not 0.
• Not reducing n. Each call must move toward the base case.
• Deep recursion on huge n. Very large n can overflow the stack — use a loop.

Summary

• Recursion is a method calling itself on a smaller problem.
• Factorial: n * factorial(n-1), base case 0! = 1.
• The base case stops the recursion — never skip it.
• Results multiply back up as the calls return.
• Use a loop instead for large n or better performance.

Next, see recursion in Floyd's triangle, or compare with loops in Java loops.