Java IllegalStateException

Introduction

IllegalStateException in Java is a runtime exception that occurs when a method is called at an inappropriate time, indicating that the object’s state is not suitable for the requested operation.

Table of Contents

1. What is IllegalStateException?
2. Common Causes
3. Handling IllegalStateException
4. Examples of IllegalStateException
5. Conclusion

1. What is IllegalStateException?

IllegalStateException signals that a method has been invoked at an inappropriate or illegal state of the object, often indicating misuse of an API or incorrect object lifecycle management.

2. Common Causes

• Calling methods before initializing the object.
• Using objects after they are closed or disposed of.
• Violating the expected sequence of method calls.

3. Handling IllegalStateException

To handle IllegalStateException:

• Ensure proper object initialization and state management.
• Implement state checks before method calls.
• Use try-catch blocks where necessary.

4. Examples of IllegalStateException

Example 1: Using an Object Before Initialization

This example demonstrates handling IllegalStateException when an object is used before proper initialization.

public class InitializationExample {
    private boolean initialized = false;

    public void initialize() {
        initialized = true;
    }

    public void performAction() {
        if (!initialized) {
            throw new IllegalStateException("Object not initialized.");
        }
        System.out.println("Action performed.");
    }

    public static void main(String[] args) {
        InitializationExample example = new InitializationExample();

        try {
            example.performAction(); // Throws IllegalStateException
        } catch (IllegalStateException e) {
            System.out.println("Error: " + e.getMessage());
        }

        example.initialize();
        example.performAction(); // Works correctly
    }
}

Output:

Error: Object not initialized.
Action performed.

Example 2: Using an Object After Closure

Here, we handle IllegalStateException when an object is used after it is closed.

public class ClosureExample {
    private boolean closed = false;

    public void close() {
        closed = true;
    }

    public void useResource() {
        if (closed) {
            throw new IllegalStateException("Resource is closed.");
        }
        System.out.println("Resource in use.");
    }

    public static void main(String[] args) {
        ClosureExample example = new ClosureExample();

        example.useResource(); // Works correctly
        example.close();

        try {
            example.useResource(); // Throws IllegalStateException
        } catch (IllegalStateException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Resource in use.
Error: Resource is closed.

5. Conclusion

IllegalStateException in Java helps ensure that methods are called only when an object is in the appropriate state. By managing object states correctly and implementing checks, you can prevent this exception and ensure robust application behavior.