Recursive Methods

public static void countdown(int n) {
    if (n == 0) {
        System.out.println("Go!");
        return;
    }
    System.out.println(n);
    countdown(n - 1);  // the method calls itself!
}

countdown(3);

3
2
1
Go!

public static int factorial(int n) {
    if (n == 0) {           // BASE CASE
        return 1;
    }
    return n * factorial(n - 1);  // RECURSIVE CASE
}

factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1 * factorial(0)
factorial(0) = 1               ← base case reached!

┌─────────────────┐
│ factorial(0) = 1 │  ← top of stack (base case)
├─────────────────┤
│ factorial(1)     │  waiting for factorial(0)
├─────────────────┤
│ factorial(2)     │  waiting for factorial(1)
├─────────────────┤
│ factorial(3)     │  waiting for factorial(2)
├─────────────────┤
│ factorial(4)     │  waiting for factorial(3)
└─────────────────┘

public static void infinite(int n) {
    System.out.println(n);
    infinite(n + 1);  // no base case — never stops!
}

// Recursive
public static int sumRecursive(int n) {
    if (n == 0) return 0;
    return n + sumRecursive(n - 1);
}

// Iterative (loop)
public static int sumIterative(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++) {
        total += i;
    }
    return total;
}

public static int power(int base, int exp) {
    if (exp == 0) return 1;              // base case: x^0 = 1
    return base * power(base, exp - 1);  // x^n = x * x^(n-1)
}

System.out.println(power(2, 5));  // 32

public static int digitSum(int n) {
    if (n < 10) return n;                // single digit — base case
    return n % 10 + digitSum(n / 10);    // last digit + sum of rest
}

System.out.println(digitSum(1234));  // 10

public static void printBefore(int n) {
    if (n == 0) return;
    System.out.print(n + " ");   // print BEFORE recursive call
    printBefore(n - 1);
}
// printBefore(3) → 3 2 1

public static void printAfter(int n) {
    if (n == 0) return;
    printAfter(n - 1);
    System.out.print(n + " ");   // print AFTER recursive call
}
// printAfter(3) → 1 2 3

public class RecursionDemo {
    // Count how many times a digit appears in a number
    public static int countDigit(int number, int digit) {
        number = Math.abs(number);  // handle negatives
        if (number < 10) {
            return (number == digit) ? 1 : 0;
        }
        int lastMatch = (number % 10 == digit) ? 1 : 0;
        return lastMatch + countDigit(number / 10, digit);
    }
    
    public static void main(String[] args) {
        System.out.println(countDigit(115511, 1));  // 4
        System.out.println(countDigit(222, 3));     // 0
        System.out.println(countDigit(12321, 2));   // 2
    }
}