Task - Exception Handling - Factorial of a Number

[akash-coded]

class MathUtils
{
 //-------------------------------------------------------------
 // Returns the factorial of the argument given
 //-------------------------------------------------------------
 public static int factorial(int n)
 {
 int fac = 1;
 for (int i=n; i>0; i--)
 fac *= i;
 return fac;
 }
} 

WAP that calls the factorial method of the MathUtils class to compute the factorials of integers entered by the user. Study the code, then compile and run Factorials to see how it works. Try several positive integers, then try a negative number. You should find that it works for small positive integers (values < 17), but that it returns a large negative value for larger integers and that it always returns 1 for negative integers.

1. Returning 1 as the factorial of any negative integer is not correct—mathematically, the factorial function is not defined for negative integers. To correct this, you could modify your factorial method to check if the argument is negative, but then what? The method must return a value, and even if it prints an error message, whatever value is returned could be misconstrued. Instead, it should throw an exception indicating that something went wrong so it could not complete its calculation. You could define your own exception class, but there is already an exception appropriate for this situation: IllegalArgumentException, which extends RuntimeException. Modify your program as follows:

• Modify the header of the factorial method to indicate that factorial can throw an IllegalArgumentException.
• Modify the body of factorial to check the value of the argument and, if it is negative, throw an IllegalArgumentException. Note that what you pass to throw is actually an instance of the IllegalArgumentException class and that the constructor takes a String parameter. Use this parameter to be specific about what the problem is.
• Compile and run your Factorials program after making these changes. Now when you enter a negative number an exception will be thrown, terminating the program. The program ends because the exception is not caught, so it is thrown by the main method, causing a runtime error.
• Modify the main method in your Factorials class to catch the exception thrown by factorial and print an appropriate message, but then continue with the loop. Think carefully about where you will need to put the try and catch.

2. Returning a negative number for values over 16 also is not correct. The problem is arithmetic overflow; the factorial is bigger than can be represented by an int. This can also be thought of as an IllegalArgumentException; this factorial method is only defined for arguments up to 16. Modify your code in factorial to check for an argument over 16 as well as for a negative argument. You should throw an IllegalArgumentException in either case, but pass different messages to the constructor so that the problem is clear.

[preeti-max]

`import java.util.Scanner;
public class MathUtil
{

public static int factorial(int n) throws IllegalArgumentException
{
if(n<0){
throw new IllegalArgumentException("Factorials of negative no is not possible");
}
if(n>16){
throw new IllegalArgumentException("Arithmetic overflow.You cannot pass a value greater than 16");
}

int fac = 1;
for (int i=n; i>0; i--)
fac *= i;
return fac;
}
public static void main(String[] args) throws IllegalArgumentException {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();

try{
    System.out.println("Factorial of no :"+factorial(n));

}
catch(IllegalArgumentException e){
    System.out.println(e);

}

}

} `

[abhiraj2k]

package exception_handling.basics;

import java.util.Scanner;

public class FactorialException {

    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Argument passed should not be less than 0");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Argument passed should not be greater than 16");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) throws IllegalArgumentException{
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println(factorial(sc.nextInt()));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[Harshita-Joshi]

`package ExceptionHandling;

import java.util.Scanner;

class MathUtils{
public static int factorial(int n) throws IllegalArgumentException{

    if(n<0)
    throw new IllegalArgumentException("No factorial possible for negative numbers!!");

    if(n>16)
    throw new IllegalArgumentException("Erroneous factorial for numbers greater than 16!!");

    int fac=1;
    for(int i=n; i>0; i--){
        fac *= i;
    }
    return fac;
}

}

public class FactorialDriver {
public static void main(String[] args) throws IllegalArgumentException{

    MathUtils maths = new MathUtils();
    Scanner scn = new Scanner(System.in);
    System.out.println("Enter ten integers: ");
    int[] arr = new int[10];
    for(int i=0; i<10; i++){
        arr[i] = scn.nextInt();
        try{
        int res = maths.factorial(arr[i]);
        System.out.println("Factorial: "+ res);
        }
        catch(IllegalArgumentException e){
            System.out.println(e.toString());
        }
    }
    

}

}
`

[mkaifahmed]

`import java.util.Scanner;

public class FactorialExcep {

public static int factorial(int n) throws IllegalArgumentException {
    if (n < 0) {
        throw new IllegalArgumentException("negative no factorial is not possible");
    }
    if (n > 16) {
        throw new IllegalArgumentException("value cannot be greater than 16");
    }

    int fac = 1;
    for (int i = n; i > 0; i--)
        fac *= i;
    return fac;
}

public static void main(String[] args) throws IllegalArgumentException {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();

    try {
        System.out.println("Factorial of no :" + factorial(n));

    } catch (IllegalArgumentException e) {
        System.out.println(e);

    }
    sc.close();
}

}`

[ps030300]

package Package1;

import java.util.*;

public class Task2 {

    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Factorial of negative number is not possible");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Integer range exceeding");
        }

        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) throws IllegalArgumentException {
        Scanner in = new Scanner(System.in);
        System.out.println("Enter the number");
        int n = in.nextInt();

        try {
            System.out.println("Factorial of no :" + factorial(n));

        } catch (IllegalArgumentException e) {
            System.out.println(e);

        }
        
    }
}

[Gaurav-Joshi-31]

import java.util.Scanner;

public class MathUtil {

    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Argument passed should not be less than 0");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Argument passed should not be greater than 16");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) throws IllegalArgumentException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        try {
            System.out.printf("Factorial of %d is %d.", n, factorial(n));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[Shubhi27]

package session11;

import java.util.Scanner;

public class FactorialCheck {

    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Factorial is not possible for negative numbers");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Number should not be greater than 16");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) throws IllegalArgumentException {
        try {
            Scanner s = new Scanner(System.in);
            int n = s.nextInt();
            System.out.println("Factorial of " + n + " is: " + factorial(n));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[Ashwesh09]

class MathUtils
{
 //-------------------------------------------------------------
 // Returns the factorial of the argument given
 //-------------------------------------------------------------
public static int factorial(int n) throws IllegalArgumentException{

        if(n < 0)
            throw new IllegalArgumentException("Negative number do not have a factorial.\n"+n+"! =  1");
        else if (n >= 16)
            throw new IllegalArgumentException("The problem is arithmetic overflow.\nThe factorial is bigger than can be represented by an int.");
        int fac = 1;
        for (int i=n; i>0; i--)
            fac *= i;
    return fac;

 }
} 

public class Factorial {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter num to find factorial of it.");
        int num = sc.nextInt();
        sc.close();
        try{
            int res = MathUtils.factorial(num);
            System.out.println(num+"! = ="+ res);
        }
        catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[Khyati-tripathi]

import java.util.Scanner;

class MathUtils {
    // -------------------------------------------------------------
    // Returns the factorial of the argument given
    // -------------------------------------------------------------
    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Factorial of negative number is not possible!");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Argument passed should be <=16");
        }

        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }
}

public class FactorialEx {
    public static void main(String[] args) throws IllegalArgumentException {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();

        try {
            System.out.println("Factorial of no :" + MathUtils.factorial(a));

        } catch (IllegalArgumentException e) {
            System.out.println(e);

        }

    }
}

[ratnadeepikavuddagiri]

import java.util.*;
class MathUtils
{
    public static int factorial (int n) throws IllegalArgumentException
    {
        if(n<0){
            throw new IllegalArgumentException("Factorial of Negative Numbers is not possible!");
        }
        if(n>16){
            throw new IllegalArgumentException("Factorial of a number above 16 is not possible!");
        }
        int fac = 1;
        for (int i=n; i>0; i--)
        fac *= i;
        return fac;
    }
} 
public class Factorial {
    public static void main(String[] args) throws IllegalArgumentException{
        MathUtils mathUtils = new MathUtils();
        int n;
        Scanner scanner = new Scanner(System.in);
        n=scanner.nextInt();
        try{
            System.out.println(mathUtils.factorial(n));
        }catch(IllegalArgumentException e){
            System.out.println(e);
        }
    }
}

[aish955]

`import java.util.Scanner;

public class exceptiontask

{

public static int factorial(int n) throws IllegalArgumentException {
    if (n < 0) {
        throw new IllegalArgumentException("Argument passed should be positive");
    }
    if (n > 16) {
        throw new IllegalArgumentException("Argument passed should be less than 16");
    }
    int fac = 1;
    for (int i = n; i > 0; i--)
        fac *= i;
    return fac;
}

public static void main(String[] args) throws IllegalArgumentException {
    try {
        Scanner sc = new Scanner(System.in);
        System.out.println(factorial(sc.nextInt()));
    } catch (IllegalArgumentException e) {
        System.out.println(e);
    }
}

}`

[Amrit-Raj22]

package week3day1;

import java.util.Scanner;

class getFactorial {

    int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("negative args");
        }
        if (n > 16) {
            throw new IllegalArgumentException("args > 16");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }
}

public class Factorial {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        getFactorial fact = new getFactorial();
        int n = scanner.nextInt();
        try {
            System.out.println(fact.factorial(n));
        } catch (IllegalArgumentException e) {
            System.out.println("illigal arg");
        }
    }

}

[RohitNaikade1]

package ExceptionHandeling;

import java.util.Scanner;

public class Recursion {

    public static int factorial(int n) {

        if(n<0){
            throw new ArithmeticException("calculate a factorial of negative value is not allowed!");
        }else if(n>16){
            throw new ArithmeticException("Dont enter a value greater than 16.it will give you a negative result!");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) {
        Scanner s1 = new Scanner(System.in);
        int num=s1.nextInt();
        try{
            System.out.println("Factorial of "+num+" is: "+factorial(num));
        }catch(ArithmeticException e){
            System.out.println(e.getMessage());
        }
    }
}

[GantaGreeshma]

`import java.util.Scanner;

class MathUtils {
public static int factorials(int n) {
int fac = 1;
if (n < 0) {
throw new IllegalArgumentException("not possible for negative values");
} else if (n >= 17) {
throw new IllegalArgumentException("cant be greater than value 16");
} else {
for (int i = n; i > 0; i--)
fac *= i;
}
return fac;
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int number = sc.nextInt();
    try {
        System.out.println(factorials(number));
    } catch (IllegalArgumentException e) {
        System.out.println(e);
    }
}

}
`

[VigneshVishwa]

import java.util.*;

public class Exception_fibonacci {
    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("n must be positive");
        }
        if (n > 16) {
            throw new IllegalArgumentException("n must be between 0 and 16");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        try {
            System.out.println("The factorial of the given number is: " + factorial(n));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }

    }
}

[SaichaitanyareddyG]

Exception Handling

`import java.util.Scanner;

public class Fact {

public static int factorial(int n) throws IllegalArgumentException {
    if (n < 0) {
        throw new IllegalArgumentException("Factorials of negative numbers is not possible");
    }
    if (n > 16) {
        throw new IllegalArgumentException("Arithmetic overflow.You cannot pass a value greater than 16");
    }

    int fact = 1;
    for (int i = n; i > 0; i--)
        fact *= i;
    return fact;
}

public static void main(String[] args) throws IllegalArgumentException {
    Scanner s = new Scanner(System.in);
    int n = s.nextInt();
    try {
        System.out.println("Factorial of " + n + " : " + factorial(n));

    } catch (IllegalArgumentException e) {
        System.out.println(e);

    }
}

}`

[uzma23]

User Defined Exceptions

import java.util.Scanner;

class MyException extends Exception {
    MyException() {

    }

    MyException(String msg) {
        super(msg);
    }

}

class MathUtils {
    // -------------------------------------------------------------
    // Returns the factorial of the argument given
    // -------------------------------------------------------------

    public static int factorial28(int n) throws MyException {
        if (n < -16) {
            throw new MyException(
                    "Negative integer provided. The factorial is bigger than can be represented by an int.");
        }
        if (n < 0) {
            throw new MyException("Negative integer provided");
        }
        if (n > 16) {
            throw new MyException("Integer greater than 16 provided");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }
}

public class discussion28 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter integer");
        int n = sc.nextInt();

        try {
            System.out.println("Factorial of no :" + MathUtils.factorial28(n));

        } catch (MyException e) {
            System.out.println(e);
        }
    }
}

[thussain520]

import java.util.Scanner;

class MathUtils
{
	public static int factorial(int n)
	{
		 if(n < 0)
		 {
			 throw new IllegalArgumentException("Please Enter a positive number for Factorial");
		 }
		 if(n > 16)
		 {
			 throw new IllegalArgumentException("Please Enter a number less than 17 to get desired output");
		 }
		 int fac = 1;
		 for (int i=n; i>0; i--)
		 fac *= i;
		 return fac;
	}
} 
public class FactCheck {
	public static void main(String[] args) {
		System.out.println("Enter a positive or negative number, negative number should be less than -17\n");
		Scanner sc = new Scanner(System.in);
		int number = sc.nextInt();
		try {
			int fact = MathUtils.factorial(number);
			System.out.println("Factorial of the number is = "+fact);
		}catch(IllegalArgumentException e)
		{
			System.out.println(e.getMessage());
			main(args);
		}
	}
}

[Desicoders]

class MathUtils {
	// -------------------------------------------------------------
	// Returns the factorial of the argument given
	// -------------------------------------------------------------
	public static int factorial(int n) throws IllegalArgumentException{
		int fac = 1;
		if(n>16)
		{
			throw new IllegalArgumentException(" arithmetic overflow : the factorial is bigger than can be represented by an int "+n);
		}
		if(n<0)
		{
			throw new IllegalArgumentException("factorial for negative number not allowed" +n);
		}
		
		for(int i = n; i > 0; i--) {
			fac *= i;
		}
		return fac;
	}
public static void main(String[] args) {
		
		for (int i=-1;i<18;i++)
		{
			try {
			System.out.println("Factorial of "+i+ "is "+MathUtils.factorial(i));
			}
			catch (Exception e)
			{
				e.printStackTrace();
				
			}
		}
		

	}
}

[rrajbanshi]

code

import java.util.Scanner;
public class Discussion28{

    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Argument passed should not be less than 0");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Argument passed should not be greater than 16");
        }
        int factorial = 1;
        for (int i = n; i > 0; i--)
            factorial *= i;
        return factorial;
    }

    public static void main(String[] args) throws IllegalArgumentException{
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println(factorial(sc.nextInt()));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[ShravanKV2310]

Code

import java.util.Scanner;

public class FactorialException {

    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Argument passed should not be less than 0");
        }
        if (n > 16) {
            throw new IllegalArgumentException("Argument passed should not be greater than 16");
        }
        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }

    public static void main(String[] args) throws IllegalArgumentException{
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println(factorial(sc.nextInt()));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[AjayBagul]

code

package assignment28;

import java.util.Scanner;

public class Factorials {
	
	public static int factorial(int n) throws IllegalArgumentException{
		
		if(n<0) {
			throw new IllegalArgumentException("VAlue should not be less than zero");
		}
		
		if(n>16) {
			throw new IllegalArgumentException("Value should not greater than 16");
		}
			int fac = 1;
			 for (int i=n; i>0; i--)
			 fac *= i;
			 return fac;
	}
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter number");
			int n = sc.nextInt();
			
			try {
				System.out.println(factorial(n));
			}catch(IllegalArgumentException e){
				System.out.println(e);
				
			}
		}
		
	}

[Sk216995]

import java.util.*;
public class MathUtil {

public static int factorial(int n)throws IllegalArgumentException {
	if(n<0) {
		throw new IllegalArgumentException("this is a negative number");
	}
	
		if(n>16){
			throw new IllegalArgumentException("this is arithmatic overflow");
		}
	
	
	
		int fac = 1;
		 for (int i=n; i>0; i--) {
		 fac *= i;
		 }
		 return fac;
		

	
}

public static void main(String[] args)throws IllegalArgumentException {
	Scanner sc=new Scanner(System.in);
	System.out.println("enter the no");
	int n=sc.nextInt();
	try {
		System.out.println("this is factorial no"+factorial(n));
	}catch(IllegalArgumentException e){
		System.out.println(e);
		
	}
	

}

}``

[Abhishekk6]

package p1;
	
	
	import java.util.Scanner;
	
	class MathUtils
	{
		public static int factorial(int n)
		{
			 if(n < 0)
			 {
				 throw new IllegalArgumentException("Please Enter a positive number for Factorial");
			 }
			 if(n > 17)
			 {
				 throw new IllegalArgumentException("Please Enter a number less than 17 to get desired output");
			 }
			 int fac = 1;
			 for (int i=n; i>0; i--)
			 fac *= i;
			 return fac;
		}
	} 
	public class FactCheck {
		public static void main(String[] args) {
			System.out.println("Enter a positive or negative number, negative number should be less than -17\n");
			Scanner sc = new Scanner(System.in);
			int number = sc.nextInt();
			try {
				int fact = MathUtils.factorial(number);
				System.out.println("Factorial of the number is = "+fact);
			}catch(IllegalArgumentException e)
			{
				System.out.println(e.getMessage());
				
			}
		}
	}

[lingamurthi]

class MathUtils {
	// -------------------------------------------------------------
	// Returns the factorial of the argument given
	// -------------------------------------------------------------
	public static int factorial(int n) throws IllegalArgumentException{
		int fac = 1;
		if(n>16)
		{
			throw new IllegalArgumentException(" arithmetic overflow : the factorial is bigger than can be represented by an int "+n);
		}
		if(n<0)
		{
			throw new IllegalArgumentException("factorial for negative number not allowed" +n);
		}
		
		for(int i = n; i > 0; i--) {
			fac *= i;
		}
		return fac;
	}
public static void main(String[] args) {
		
		for (int i=-1;i<18;i++)
		{
			try {
			System.out.println("Factorial of "+i+ "is "+MathUtils.factorial(i));
			}
			catch (Exception e)
			{
				e.printStackTrace();
				
			}
		}
		

	}
}

[Gauravkumar930]

import java.util.Scanner;

public class Factorial {

    public static int factorial(int num) throws IllegalArgumentException {
        if (num < 0) {
            throw new IllegalArgumentException("Argument passed should not be less than 0");
        }
        else if (num > 20) {
            throw new IllegalArgumentException("Argument passed should not be greater than 20");
        }
        else {
        	int fact = 1;
            for (int i = 1; i <= num; i++)
                fact *= i;
            return fact;
        }
    }

    public static void main(String[] args) throws IllegalArgumentException{
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println(factorial(sc.nextInt()));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[Shivani2145]

import java.util.Scanner;

public class Factorial {

    public static int factorial(int num) throws IllegalArgumentException {
        if (num < 0) {
            throw new IllegalArgumentException("Argument passed should not be less than 0");
        }
        else if (num > 20) {
            throw new IllegalArgumentException("Argument passed should not be greater than 20");
        }
        else {
        	int fact = 1;
            for (int i = 1; i <= num; i++)
                fact *= i;
            return fact;
        }
    }

    public static void main(String[] args) throws IllegalArgumentException{
        try {
            Scanner sc = new Scanner(System.in);
            System.out.println(factorial(sc.nextInt()));
        } catch (IllegalArgumentException e) {
            System.out.println(e);
        }
    }
}

[nandhusekar]

Naga Nandhini

import java.util.Scanner;

public class Factorials {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.print("Enter an integer to compute its factorial (or type 'exit' to quit): ");
            String input = sc.nextLine();

            if (input.equalsIgnoreCase("exit")) {
                System.out.println("Exiting...");
                break;
            }

            try {
                int num = Integer.parseInt(input);
                int result = MathUtils.factorial(num);
                System.out.println("Factorial of " + num + " is: " + result);
            } catch (IllegalArgumentException e) {
                System.out.println("Error: " + e.getMessage());
            } catch (NumberFormatException e) {
                System.out.println("Invalid input. Please enter a valid integer.");
            }
        }

        sc.close();
    }
}

class MathUtils {
    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0)
            throw new IllegalArgumentException("Factorial is not defined for negative numbers.");
        if (n > 16)
            throw new IllegalArgumentException("Input too large. Factorial is only supported for values <= 16.");

        int fac = 1;
        for (int i = n; i > 0; i--)
            fac *= i;
        return fac;
    }
}

[prasetha21-max]

PRASETHA N

package com.practice.problems.java;

import java.util.Scanner;

public class Factorials {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int n = sc.nextInt();

        try {
            System.out.println("Factorial of no: " + MathUtils.factorial(n));
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }


    }
}

class MathUtils {
    public static int factorial(int n) throws IllegalArgumentException {
        if (n < 0) {
            throw new IllegalArgumentException("Factorial is not defined for negative numbers: " + n);
        }
        if (n > 16) {
            throw new IllegalArgumentException("Factorial result too large to fit in int for: " + n);
        }

        int fac = 1;
        for (int i = n; i > 0; i--) {
            fac *= i;
        }
        return fac;
    }
}

[Sdey0907]

Task - Exception Handling - Factorial of a Number - Sayan Dey - Completed

import java.util.Scanner;

class MathUtils {

public static int factorial(int n) {
    if (n < 0) {
        throw new IllegalArgumentException("Factorial is not defined for negative integers: " + n);
    }
    if (n > 16) {
        throw new IllegalArgumentException("Factorial result overflows int for values > 16: " + n);
    }

    int fac = 1;
    for (int i = n; i > 0; i--) {
        fac *= i;
    }
    return fac;
}

}

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String choice;

    do {
        System.out.print("Enter an integer to compute its factorial: ");
        int number = sc.nextInt();

        try {
            int result = MathUtils.factorial(number);
            System.out.println("Factorial of " + number + " is: " + result);
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }

        System.out.print("Do you want to compute another factorial? (yes/no): ");
        choice = sc.next();
    } while (choice.equalsIgnoreCase("yes"));

    System.out.println("Program terminated.");
    sc.close();
}

}

[vbhavana1]

import java.util.Scanner;

public class MathUtil {

public static int factorial(int n) throws IllegalArgumentException {
    if (n < 0) {
        throw new IllegalArgumentException("Argument passed should not be less than 0");
    }
    if (n > 16) {
        throw new IllegalArgumentException("Argument passed should not be greater than 16");
    }
    int fac = 1;
    for (int i = n; i > 0; i--)
        fac *= i;
    return fac;
}

public static void main(String[] args) throws IllegalArgumentException {
	System.out.println("Enter Number");
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    try {
        System.out.printf("Factorial of %d is %d.", n, factorial(n));
    } catch (IllegalArgumentException e) {
        System.out.println(e);
    }
}

}