Java Program to Calculate Factorial Using Recursion

In this article, we will discuss how to calculate the factorial of a number using recursion in Java. A factorial of a non-negative integer nnn is the product of all positive integers less than or equal to nnn. It is denoted as n!n!n!, and is defined as:

n!=n×(n−1)×(n−2)×⋯×1n! = n \times (n-1) \times (n-2) \times \dots \times 1n!=n×(n−1)×(n−2)×⋯×1

For example.

• 5!=5×4×3×2×1=1205! = 5 \times 4 \times 3 \times 2 \times 1 = 1205!=5×4×3×2×1=120
• 0!=10! = 10!=1 (by definition)

Recursion is a process that a method calls itself. In the case of calculating factorials, the factorial of a number can be broken down into smaller subproblems, where the factorial of nnn is calculated as:

n!=n×(n−1)!n! = n \times (n-1)!n!=n×(n−1)!

Here, (n−1)!(n-1)!(n−1)! is calculated recursively until we reach the base case, which is 0!=10! = 10!=1.

Steps to Implement Factorial Calculation Using Recursion

1. Base Case: The base case is the condition where recursion stops. In this case, 0!=10! = 10!=1.
2. Recursive Case: The recursive case involves calling the factorial method with a smaller value of nnn until the base case is reached.

Java Code to Calculate Factorial Using Recursion

Here is the Java code that demonstrates how to calculate the factorial of a number using recursion.

import java.util.Scanner;

public class Factorial {

    // Method to calculate factorial using recursion
    public static int factorial(int n) {
        // Base case: factorial of 0 or 1 is 1
        if (n == 0 || n == 1) {
            return 1;
        } else {
            // Recursive case: n! = n * (n-1)!
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        // Create a scanner object to get user input
        Scanner scanner = new Scanner(System.in);
        
        // Ask the user for a number
        System.out.print("Enter a number to find its factorial: ");
        int num = scanner.nextInt();
        
        // Calculate the factorial
        int result = factorial(num);
        
        // Display the result
        System.out.println("Factorial of " + num + " is: " + result);
        
        // Close the scanner
        scanner.close();
    }
}

Explanation of the Code

1. factorial(int n) Method
   • This method takes an integer nnn and recursively calculates its factorial.
   • If nnn is 0 or 1 (the base case), it returns 1.
   • Otherwise, it calls itself with the value n−1n - 1n−1, multiplying the result by nnn.
2. main Method
   • The main method prompts the user to input a number.
   • It calls the factorial() method with the user’s input and prints the result.

Sample Output

Let's look at a few examples of how the program works.

Example 1

Example 2

How does the Recursion work?

For n=5n = 5n=5, the method calls unfold like this.

• 5!=5×4!5! = 5 \times 4!5!=5×4!
• 4!=4×3!4! = 4 \times 3!4!=4×3!
• 3!=3×2!3! = 3 \times 2!3!=3×2!
• 2!=2×1!2! = 2 \times 1!2!=2×1!
• 1!=11! = 11!=1

Once the base case 1!=11! = 11!=1 is reached, the recursion "unwinds", and the final result is computed.

• 1!=11! = 11!=1
• 2!=2×1=22! = 2 \times 1 = 22!=2×1=2
• 3!=3×2=63! = 3 \times 2 = 63!=3×2=6
• 4!=4×6=244! = 4 \times 6 = 244!=4×6=24
• 5!=5×24=1205! = 5 \times 24 = 1205!=5×24=120

Conclusion

Using recursion to calculate the factorial of a number is a simple and intuitive approach in Java. It demonstrates how a problem can be broken down into smaller subproblems and solved step by step. However, for very large numbers, you might want to consider an iterative approach or memoization to optimize the performance.

By understanding recursion and how it applies to problems like factorial calculation, you can gain a deeper insight into problem-solving techniques in programming.