State the Purpose of Java Exceptions

Java Exceptions provide a formal way of handling error conditions that might arise in your software or in software that you are using. In addition to responding to an exception, you can also signal (or throw) your own exception, as you will learn about shortly.

• Three Advantages of Java Exceptions
  1. Allows for the creation of new exceptions that are custom to a particular application domain.
  2. It improves code because error handling code is clearly separated from the main program logic.
  3. Java's exception mechanism improves the code because it does not have to include error handling code if it is not capable of handling it.

The purpose of exceptions in Java SE 17 is to provide a mechanism for handling 1) runtime errors or 2) exceptional conditions in a structured and controlled manner. Exceptions allow developers to separate the logic of error detection from the logic of error handling, improving code readability and robustness. Here are the primary purposes of exceptions:

1. Error Reporting
   • Exceptions notify the program about unexpected issues during execution, such as:
     • File not found (FileNotFoundException)
     • Invalid user input (NumberFormatException)
     • Division by zero (ArithmeticException)
2. Program Flow Control
   • Exceptions help to:
     • Immediately transfer control from the point where the error occurred to an appropriate exception handler (try-catch block).
     • Avoid the need for error-checking logic in the main code flow, making the code cleaner.
3. Custom Error Handling
   • Developers can define custom exceptions to represent specific application or domain-related errors.
   • Provides meaningful error messages and recovery options.
4. Maintainability and Debugging
   • Exception stack traces give detailed insights about where and why an error occurred.
   • Encourages consistent error-handling patterns across an application.
5. Separation of Concerns
   • The separation of normal logic from error-handling logic reduces complexity and makes the code easier to understand and maintain.

Key Concepts in Java SE 17 Related to Exceptions

• Checked Exceptions: Must be handled or declared in the method signature (e.g., IOException).
• Unchecked Exceptions: Can propagate without being explicitly handled (e.g., NullPointerException).
• Try-With-Resources: Automatically closes resources, introduced in Java 7, but enhanced with additional features in later versions.
• Records and Exceptions: In Java 17, record classes provide an elegant way to represent exception data when creating custom exceptions.

By using exceptions effectively, Java SE 17 applications can handle errors gracefully and remain robust and user-friendly.

Exceptions often provide information concerning why they were triggered, because Exception is a subclass of Throwable. Throwable defines a method called getMessage(), which returns a String describing what went wrong. One way to assist with debugging is to write this message to the standard output or the standard error in the exception handler, as in

1. System.out.println(e.getMessage()), or
2. System.err.println(e.getMessage()).

Why use exceptions?
Exceptions came about to solve a sticky problem with error handling that has existed since the beginning of programming. It has to do with at least two factors:

1. The difficulty of separating error reporting and error handling
2. The difficult-to-read programs which result from mixing code that runs when everything goes as expected with code that runs only when the unexpected occurs (sometimes error-handling code is trickier than the code that runs when everything goes right)

A perfect example involves data conversion. We can create an instance of a wrapper class, such as Integer, by supplying it with a String as a parameter to its constructor, as in:

Integer myIntWrapper = new Integer(s);

Notice that there is no result value indicating whether the constructor was successful in creating the new instance. So what happens when s does not contain a valid number?
Without exceptions, there are at least three possibilities:

1. The constructor could not create a new instance and instead returned null.
2. The constructor could create a new instance anyway, but initialized to some default value, such as zero (0).
3. The constructor could try to determine what number the invalid text might represent and work with its best guess.

Next let's discuss how Java separates error detection and error handling.