Before jumping into the code for Java Program Factorial let’s define what a factorial is?

Definition: A factorial is a function that multiplies a number by every number below it. For example 5!= 5*4*3*2*1=120. The function is used, among other things, to find the number of way “n” objects can be arranged. Factorial. ## Java Program For Factorial Code

``````public class Factorial {
public static void main(String[] args) {
int n = 5; // input
int i;
double fact = 1;
System.out.print(n+"! = ");
for(i = 1; i < n; i++) {
fact *= i;
System.out.print(i+" x ");
}
fact *= i;
System.out.print(i+" = "+ fact);
}
}
``````

OUTPUT

``5! = 1 x 2 x 3 x 4 x 5 = 120.0``

EXPLANATION

Here we use a for loop to iterate from 1 to the given number and store their product in fact. It is a pretty straightforward solution to this problem. But the problem remains unsolved. Observing keenly we see that we don’t validate the input at all! We must adjust our program to handle negative inputs. Here’s how we can do it?

``````public class Factorial {
public static void main(String[] args)throws WrongInputException{
try {
int n = -5; // input
if(n<0)
throw new WrongInputException("n cannot be less than zero!");
int i;
double fact = 1;
System.out.print(n+"! = ");
for(i = 1; i < n; i++) {
fact *= i;
System.out.print(i+" x ");
}
fact *= i;
System.out.print(i+" = "+ fact);
}catch(WrongInputException w) {
System.out.println("*******Program ends*******");
}
}
}
class WrongInputException extends Exception{
public WrongInputException(String msg) {
System.out.println(msg);
}
}``````

OUTPUT

``````n cannot be less than zero!
*******Program ends*******``````

EXPLANATION

To handle the error we create a custom WrongInputException. Now throw it when input is less than 0. The entire code is wrapped in a try-catch block. Therefore, as soon as the error is thrown the catch block executes and marks the end of the program.

Still, the input part of the code seems unsatisfactory.

Let’s improve it using the Scanner class in Java to accept console-based user input.

### Improved Java Factorial Program

``````import java.util.Scanner;

public class Factorial {
public static void main(String[] args)throws WrongInputException{
try {
Scanner sc = new Scanner(System.in);
System.out.println("enter number to calculate factorial: ");
int n = sc.nextInt();// input
if(n<0)
throw new WrongInputException("N cannot be less than zero!");
int i;
double fact = 1;
System.out.print(n+"! = ");
for(i = 1; i < n; i++) {
fact *= i;
System.out.print(i+" x ");
}
fact *= i;
System.out.print(i+" = "+ fact);
}catch(WrongInputException w) {
System.out.println("*******Program ends*******");
}
}
}
class WrongInputException extends Exception{
public WrongInputException(String msg) {
System.out.println(msg);
}
}``````

OUTPUT

``````enter number to calculate factorial:
6
6! = 1 x 2 x 3 x 4 x 5 x 6 = 720.0``````

## Java Program for Factorial with Recursion Using recursion Factorial can be easily implemented in Java just by returning the number n multiplied with a factorial of (n-1). We use a base case that if n is less or equal to 1 we return 1. This resolves the call stack step by step from fact(1) to fact(n) . Ultimately producing the desired result.

``````public class FactorialRecursion {

static int fact(int n) {
if(n <= 1)
return 1;
return n * fact(n-1);
}
public static void main(String[] args) {
int n = 5;
System.out.println("factorial of "+n+": "+fact(n));
}
}
``````

OUTPUT

``factorial of 5: 120``

## Java Program of Factorial Using Tail End Recursion

Benefits of tail-recursion

• Uses very few stack-frames for tail-recursive calls.
• Consumes less memory.
• No more StackOverflowException issues.

We can improve the Java Program for Recursion using tail-end recursion. Hers how we do it.

``````public class FactorialRecursion {

static int fact(int n, int a) {// Tail-end Recursion
if(n <= 1)
return a; // a acts as the accumulator
return fact(n-1,a*n);
}
public static void main(String[] args) {
int n = 3;
System.out.println("factorial of "+n+": "+fact(n,1));
}
}
``````

OUTPUT

``factorial of 3: 6``

In Tail-end Recursion the last operation on the recursive function is the recursive call. Hence no need to maintain a call stack like the previous code for the statement n*fact(n-1).