## Introduction to Factorial in Java

In this article, we will learn about various ways of writing code in Java Programming Language for the purpose of Factorial Calculations. Being one of the Easy to Use, Object-Oriented Language, Java, is Platform Independent and a Simple Programming Language. Java’s Compiler and Interpreter were developed with Security as a major aspect. Java has various range of applications.

Factorial, symbolized as “!” (exclamation mark), is a Mathematical operation of Multiplying a number with all the smaller numbers. For example, if the number is 5, output for factorial will be 5! = 5*4*3*2*1 = 120.

### How to Execute a Java Program?

1. Complete your code and save it as (filename).java

2. Open Terminal and run the following java command.

- a. javac (filename).java

3. The above command will generate a class file.

4. Now, execute the class file.

- a. java (filename)

### Calculation of Factorial using various Methods

#### Example 1 – Factorial program in Java using the Basic Method

Moving forward, we will now write a simple Java Program for Factorial Calculation.

`public class Factorial`

{

public static void main(String args[])

{int i, fact=1;

int number=5;

for(i=1;i<=number;i++)

{

fact=fact*i;

}

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

}

}

Save the above code with any filename and .java extension.

**Code Explanation:**

It started with two variables, “i” and “fact,” with value of 1, then “number” with 5, which is our number to calculate the factorial. I went into For Loop, kept increasing the value of i until we matched it with a number, i.e. 5. While incrementing, every time value of fact increases, it is multiplied, and the fact is assigned a new value.

**Output**:

#### Example 2 – Factorial program in Java using User Input

Another commonly used method is where we ask for a user input number for calculation instead of pre-defining it.

41 Online Courses | 29 Hands-on Projects| 305+ Hours| Verifiable Certificate of Completion

4.8

View Course

Refer to the below code for User Input Based Calculation:

`import java.util.Scanner;`

class Facto{

public static void main(String args[]) {

int q, a, fact = 1;

System.out.println("Please Enter a number:");

Scanner in = new Scanner(System.in);

q = in.nextInt();

if ( q < 0 )

System.out.println("Please enter a number greater than 0:");

else {

for ( a = 1 ; a <= q ; a++ )

fact = fact*a;

System.out.println("Factorial of "+q+" is = "+fact);

}

}

}

Save the above code as we did for the earlier example.

**Code Explanation:**

A major difference between the earlier and above example is the user input; Rest is the same. Code will ask for a number to be calculated, then if the number entered by the user is Negative that is in “-”, minus, it will prompt “Please enter a number greater than 0:”, which is obvious as Factorial cannot be calculated for Negative number. Now, it will accept a positive number and proceed with Calculating Factorial and then print the output as shown in the below image.

**Output**:

#### Example 3 – Factorial program in Java using Recursion Method

Recursion is one of the most useful tools in the world of programming. Recursion basically means reusing the function. So to say, we won’t have to define an extra number of variables here, which means we’ll have only two variables or less.

A major reason to implement Recursion is the power to reduce the code length and elegantly reduce the time complexity of a program. The recursion method, with its advantages, has a few disadvantages that could have a major impact in the long run.

#### Disadvantages

Disadvantages with recursion:

- Basically, it is quite difficult to debug the recursion code and trace it for any step with an error.
- Other than that, recursion uses more memory, as it uses Stack to accomplish the task, where it keeps adding up the stack with a newer recursive call.
- And, if not implemented wisely, Recursion can slow down the function.
- StackOverflowException: Recursive methods often throw this Exception due to the overuse of stack.

Refer to the below code:

`public class FactorialExample2 {`

static int factorial(int n){

if (n == 1)

return 1;

else

return(n * factorial(n-1));

}

public static void main(String[] args) {

System.out.println("Factorial of 5 is: "+factorial(5));

}

}

Save and compile the program as we did earlier.

**Code Explanation:**

The above code starts with a single int variable and checks if it is equal to 1; if yes, it returns one, as factorial for 1 is 1. If not equal to 1, it proceeds with the recursion function. Our int value, for example, is 5, so it’ll be like “5 * factorial(5-1)”, factorial is called here for the second time, which is another call. Then it returns again with a newer int value, which is 4, “4 * factorial(4-1)”, now it’ll be the third call to the recursion method. Now, the newer int value is 3, which means “3 * factorial(3-1)”, now it’ll be the fourth call, and the value will be 2, which means “2 * factorial(2-1)”. The int value will be one in the next recursive call, which will terminate the function here. While every call was made, its value was saved in a Stack, which is a LIFO method. So, for the final Output, the result will be “5*4*3*2*1 = 120.”

Compared to other methods, Recursion is quite difficult to understand and to implement, but if understood well and implemented wisely, it is a good tool.

**Output**:

It is highly recommended to use Recursion only in the case where writing an iterative code can be quite complex.

Now that we have learned various methods for implementing Factorial Calculations in Java Let’s explore a Built-in function that does the same work in a single line.

#### Example 4 – Factorial program in Java using built-in Function

***) IntMath**

Understanding the need for arithmetic operations over a value, a few functions specific to certain value types were written, we will see the Integer type value in work.

IntMath is a class for arithmetic calculations on an int value. IntMath class comes with a range of arithmetic operations, including factorial.

**Syntax**:

`factorial (int n)`

### Conclusion – Factorial in Java

We started with an introduction to java and how to run a java program. Then we learned about Factorial Calculation and various methods, including Recursion, to accomplish it.

Towards the end, we learned about IntMath; a Java Function primarily focused on Arithmetic operations. Java is a widely-used programming language; it comes with many features; in this article, we learned about Factorial Calculations in Java, which is a tiny aspect.

### Recommended Articles

This is a guide to Factorial in Java. Here we discuss how to execute the java program along with its methods. You may also look at the following articles to learn more-