Arithmetic Exception in Java

In this post, we will look into Arithmetic Exception in Java, root causes of Arithmetic Exception, handling Arithmetic Exceptions and Best Practices.

Arithmetic Exception in Java

What is Arithmetic Exception in Java?

An “Arithmetic Exception” represents a category of runtime exceptions that arise due to erroneous mathematical operations. These exceptions occur when specific mathematical computations lead to undefined or impossible results, disrupting the normal flow of a program.

Root Causes of Arithmetic Exception in Java

Division by Zero

One common scenario that triggers an Arithmetic Exception is attempting to divide a number by zero. Since division by zero is mathematically undefined, Java raises an Arithmetic Exception to alert the programmer to this computational error.

public class ArithmeticExceptionExample {
    public static void main(String[] args) {
        int numerator = 10;
        int denominator = 0; // Attempting to divide by zero
        int result = numerator / denominator; // Division by zero triggers an exception
        System.out.println("Result: " + result);


Exception in thread "main" java.lang.ArithmeticException: / by zero
at ArithmeticExceptionExample.main(

Division of Non-Terminating BigDecimal

Java can sometimes result in an “ArithmeticException” due to non-terminating or repeating decimals.

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalDivisionHandlingException {
    public static void main(String[] args) {
        // Define non-terminating decimals
        BigDecimal numerator = new BigDecimal("1");
        BigDecimal denominator = new BigDecimal("3");
        BigDecimal result = numerator.divide(denominator);
        System.out.println("Result: " + result);


Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
at java.base/java.math.BigDecimal.divide( BigDecimalDivisionHandlingException.main(

Handling Arithmetic Exceptions

Using try-catch block, we can handle Arithmetic Exception in Java.

public class ArithmeticExceptionHandling {
    public static void main(String[] args) {
        int numerator = 10;
        int denominator = 0;

        try {
            int result = numerator / denominator;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Exception Caught: " + e.getMessage());


Exception Caught: / by zero

In this example, we attempt to perform a division operation (numerator / denominator) where denominator is set to zero. Dividing by zero triggers an “ArithmeticException.” To prevent the program from crashing, we enclose the division operation within a try block and catch the exception using a catch block specifically targeting ArithmeticException.

Best Practices: Arithmetic Exception in Java

Let’s delve into these best practices to effectively manage numeric errors:

  1. Use Try-Catch Blocks: Wrap risky arithmetic operations in try-catch blocks to catch exceptions and prevent program crashes. This fosters graceful error handling.
  2. Specific Exception Catching: Catch specific exceptions like ArithmeticException to handle numeric errors accurately. This prevents catching unrelated exceptions and allows precise handling.
  3. Provide Meaningful Messages: In catch blocks, offer clear and meaningful error messages to help users and developers understand the issue. This enhances troubleshooting and user experience.
  4. Alternative Actions: In catch blocks, execute alternative actions or fallback mechanisms instead of letting the program halt. For instance, provide default values or prompt the user for valid inputs.
  5. Log Exceptions: Use logging frameworks like java.util.logging or third-party libraries to log exceptions. This aids in debugging and identifying the root causes of errors.
  6. Input Validation: Validate user inputs before performing arithmetic operations to prevent erroneous data from triggering exceptions.
  7. BigDecimal for Precision: Use BigDecimal for computations involving non-terminating decimals or where precision matters. This prevents rounding errors and precision loss.
  8. Set Scale and Rounding: When using BigDecimal, always set an appropriate scale and rounding mode for division operations to avoid unexpected precision issues.
  9. Prevent Division by Zero: Ensure that denominators are never set to zero before performing division operations. Validate input values and handle zero cases explicitly.
  10. Unit Testing: Write unit tests that cover scenarios involving arithmetic operations and exceptions. This helps identify issues early in the development cycle.

Conclusion: Arithmetic Exception in Java

Arithmetic exceptions, though challenging, are an integral part of Java programming that demand attention and skillful handling.

In this article “Arithmetic Exception in Java”, we discussed what is Arithmetic Exception, causes of Arithmetic Exception and best practices. Hopefully, this article will help you in tackling Arithmetic Exception in your code.

Leave a Reply

Your email address will not be published. Required fields are marked *