Exception Handling Throwing exceptions

In Java, you can throw exceptions manually using the `throw` keyword. This is useful in situations where you want to handle an error or unexpected event in a specific way. Here are some basics of throwing exceptions in Java:

1. Creating a new exception: To throw an exception, you must first create an instance of an exception class. In Java, there are many built-in exception classes that you can use, or you can create your own custom exception classes. To create a new exception, you can use the `new` keyword followed by the exception class name and a message describing the error. For example:

throw new IllegalArgumentException("Invalid argument");

Here, a new `IllegalArgumentException` is created with a message “Invalid argument”.

2. Throwing an exception: Once you have created an exception object, you can throw it using the `throw` keyword. For example:

public void divide(int x, int y) {
    if (y == 0) {
        throw new ArithmeticException("Division by zero");
    }
    int result = x / y;
    // use the result here
}

Here, an `ArithmeticException` is thrown if the denominator is 0.

3. Handling a thrown exception: When an exception is thrown, it can be handled using a try-catch block. If the exception is not caught, it will propagate up the call stack until it is caught or the program terminates. For example:

try {
    divide(10, 0);
} catch (ArithmeticException e) {
    System.err.println("Error: " + e.getMessage());
}

Here, the `divide` method is called with a denominator of 0, which throws an `ArithmeticException`. The catch block catches the exception and prints an error message.

Throwing exceptions in Java is an important part of writing robust and reliable code. By throwing exceptions and handling them appropriately, you can handle errors and unexpected events in a systematic way and write more maintainable code.