Exception Handling

Introduction to Exception Handling

• Software is correct if it performs its designed tasks effectively.
• Software is robust when it functions properly even with errors.
• An example of correct software is a program that sorts numbers in ascending order, consistently producing correct results.
• A program is considered robust if it handles non-numeric data by displaying an error message or ignoring it.
• Multiple errors are possible during an application's development and execution.
• Syntax errors are common and occur at compile time, like misspelled keywords.
• Runtime errors occur during execution, where the application environment disallows the execution of a program instruction.
• Logic errors occur when syntax and execution are error-free, but the obtained results are unexpected.
• Exceptions can interrupt a correct program's execution due to exceptional events such as incorrect data types and premature file ends.
• An exception is an event that stops a program's usual operation during runtime.
• Program designers should predict possible errors by adding test sequences or setting up a system to signal abnormal operation by returning specific values.
• It is hard to count all the possible errors without omitting any of them or the code becomes tedious.

Exceptions Overview

• Java offers a flexible exception handling mechanism to identify and manage errors during program execution.
• This mechanism addresses the abnormal operation of code sections.
• An example of exception handling; if the user enters zero as the second value, the following message is displayed: Exception in thread "main" java.lang.ArithmeticException : / by zero at TestException.main (TestException.java:6)

Types of Exceptions

• There are three types of exceptions: Errors (serious), Exceptions (common), and RuntimeExceptions (language).
• Errors are serious problems beyond the program's control, like hardware issues, and cannot be fixed.
• Errors are classified as Error or subclasses like Virtual Machine Error or IOError.
• Checked Exceptions are errors a program should expect and handle and are of type Exception.
• An example of a checked exception is when an app asks for a file name, but the file doesn't exist, triggering a java.io.FileNotFound exception.
• RuntimeException is a subclass of Exception that occurs within the program itself, related to the language, and can be handled by the programmer.
• RuntimeExceptions include arithmetic errors (division by zero), pointer errors, and indexing errors.

Handling Exceptions

• A checked exception extends the Exception class and can be standard or customized.
• A Java program should handle checked exceptions in one of two ways: by catching it with a try-catch block or propagating it with the throws keyword.
• The try clause encapsulates code that represents the program's normal operation but may generate errors.
• The catch clause specifies a code block that handles a specific exception type, executed when an instance of the exception class is thrown.
• During program execution, a statement or method may encounter an unhandled problem, resulting in an exception.
• A method can handle the exception itself using a try-catch block or allow it to pass to the calling method.
• If an exception occurs outside a try block: the method stops, the exception is passed back to the calling method, and control is transferred to the calling method.
• The calling method can either catch and handle the exception or allow it to propagate.
• If an exception occurs within a try block and matches a catch block, the corresponding catch block is executed, and execution continues.
• If no matching catch block exists, the method stops, and the exception is passed back to the calling method.
• If statements within the try block don't cause exceptions, the try block proceeds as if there were no try-catch block.
• If the catch block is empty, the caught exception is ignored; However, it's recommended to have appropriate treatment when catching an exception.
• Avoid displaying a generic message in the catch block.
• Instead, display the printStackTrace method to identify and resolve the issue.
• Variables declared inside a try block cannot be accessed inside a catch block; common variables should be declared outside the try-catch.
• If an exception propagates back to the main method unhandled, the program halts.
• It displays an error message describing the sequence of method calls that led to the exception.
• If there are multiple types of errors and exceptions, a separate catch block is required for each type of event.
• In the sequential order of catch clauses, the order should be from most specific to least specific exception types in terms of their hierarchy.
• More specific exceptions (subclasses) are handled before more general exceptions to avoid compiler errors.
• If an exception interrupts the execution, a block of instructions can be included that will always execute, regardless of whether an exception is handled.
• This block of code happens either after the try block if there were no exceptions or after the catch block if an exception was caught.
• The finally block is introduced by the "finally" keyword and placed after the last catch block.
• Statements in the finally block often perform cleanup or resource release actions, like closing a file or a network connection.

Throwing Exceptions

• Any method that may throw a checked exception must either have a try/catch block or declare using the throws keyword.
• If an exception occurs, it goes upward through the execution stack, looking for a code piece capable of handling it.
• The method itself determines the exceptions it may throw, either from JDK-provided exception classes or custom classes.
• Exceptions classes can be created by subclassing the Exception class.
• By convention, include "Exception" in the custom exceptions name.
• With a custom exception you must use the "throw" keyword followed by an instance of the custom exception class.
• Custom exceptions can be made for specific needs of the method such as non-negative coordinates.
• If a method has "throws XXException", the calling method must include the call in a "try-catch(XXException)" block or declare it can throw XXException.

The Throwable Class

• It is the parent class of all exceptions and is descended from the Object class.
• The main methods are:
• String getMessage(): Returns the message associated with the exception.
• void printStackTrace(): Displays the error message and the stack trace, which shows the sequence of method calls that caused the problem.
• void printStackTrace(PrintStream s): Performs the same action as printStackTrace(), but with its result to a specified PrintStream.