Illegal Argument Exception Examples

Introduction to Illegal Argument Exception

In Java programming, an IllegalArgumentException is thrown to indicate that a method has been passed an illegal or inappropriate argument. This exception is a runtime error, and it often occurs when the input provided to a method does not meet the expected criteria, leading to potential issues in the program’s execution. Understanding IllegalArgumentException is crucial for developers to debug and create robust applications. Below are three diverse examples that illustrate this exception in practical scenarios.

Example 1: Negative Number in Square Root Calculation

In this example, we will demonstrate how passing a negative number to a method that calculates the square root can trigger an IllegalArgumentException. This is a common scenario in mathematical computations where the input must be non-negative.

public class MathUtil {
    public static double calculateSquareRoot(double number) {
        if (number < 0) {
            throw new IllegalArgumentException("Number must be non-negative");
        }
        return Math.sqrt(number);
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            double result = MathUtil.calculateSquareRoot(-9);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage()); // Output: Number must be non-negative
        }
    }
}

In this code, when calculateSquareRoot is called with -9, the program throws an IllegalArgumentException, preventing the calculation of the square root of a negative number, which is undefined.

Notes:

• Consider using Math.abs() if you want to handle negative inputs differently.
• Always validate user inputs to avoid such exceptions.

Example 2: Invalid Age in User Registration

This example illustrates how an IllegalArgumentException can arise during user registration when an invalid age is provided. Age should logically be a non-negative integer, and this constraint can be enforced in the registration method.

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            User user = new User("Alice", -5);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage()); // Output: Age cannot be negative
        }
    }
}

Here, the constructor of the User class checks if the age is negative. If it is, an IllegalArgumentException is thrown, ensuring that only valid user data is processed.

Notes:

• Consider adding additional validation for maximum age limits.
• Exception handling can be used to provide user-friendly feedback.

Example 3: Incorrect Array Size in Array Operations

In this scenario, an IllegalArgumentException can occur when trying to initialize an array with an inappropriate size. This often happens when the size is passed as an argument to a method that expects a positive integer.

public class ArrayUtil {
    public static int[] createArray(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("Size must be a positive integer");
        }
        return new int[size];
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            int[] myArray = ArrayUtil.createArray(0);
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage()); // Output: Size must be a positive integer
        }
    }
}

In this example, the createArray method checks whether the supplied size is a positive integer. If not, it throws an IllegalArgumentException, preventing the creation of an array with an invalid size.

Notes:

• Users should be informed about valid input ranges when designing APIs.
• Consider using default values if appropriate, rather than throwing an exception.