1. Exception Handling Contents
Many classes in the Java standard library throw exceptions
“throws clause” (or try-catch block) is needed in the function header of any function that contains a message to a library method that throws an exception
Error message if “throws clause” or try-catch blocks are missing
Types of exceptions
Try-catch blocks
The Exception hierarchy
An example using try-catch blocks
The anatomy of an exception

2. Exception Handling
Most of Java’s I/O classes (and many others) throw exceptions.
For example: Consider a function with a message readLine( ) directed to a BufferedInputReader object
import java.io.*;
//needed for streams and IOException
public class ExceptionalExample {
public static void main(String [ ] args) {
throws IOException
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.println(“Enter a number”);
String str = br.readLine( );
The statement “throws IOException” is required when using readLine( ). It must be included in the header of any function in which readLine( ) appears.
Provide stream readers to convert characters (read as integers) into a string, then prompt the user for a number.
Read the supplied number (as a String) from the keyboard.

3. Exception Handling
If we fail to include the “throws IOException” clause in the main function header we will see the following error reported when we compile the program ExceptionalExample:
c:\javacode>javac ExceptionalExample.java
ExceptionalExample.java:10: unreported exception java.io.IOException; must be caught or declared to be thrown
String str = readLine( );
1 error
c:\javacode> ^
Method readLine( ) throws an IOException. Any function that uses it must either throw the same exception (and pass the buck to the operating system to handle the exception) or catch the exception and provide its own error handling methodology. In the previous example we chose the first strategy.

4. Exception Handling Types of exceptions
Checked exceptions – inability to acquire system resources (such as insufficient memory, file does not exist)
Java checks at compile time that some mechanism is explicitly in place to receive and process an exception object that may be created during runtime due to one of these exceptions occurring.
Unchecked exceptions – exceptions that occur because of the user entering bad data, or failing to enter data at all.
Unchecked exceptions can be avoided by writing more robust code that protects against bad input values. Java does not check at compile time to ensure that there is a mechanism in place to handle such errors.
It is often preferred to use Java’s exception handling capabilities to handle bad user input rather than trying to avoid such circumstances by providing user-input validation in the code.

5. Exception Handling The try / catch blocks try {
//statements – one of which is capable of throwing an exception }
catch (ExceptionTypeName objName) {
//one or more statements to execute if this exception occurs }
finally {
//statements to be executed whether or not exception occurs }
Encapsulate statement or statements that can throw an exception in a try block.
One or more catch blocks must immediately follow a try block to provide error handling routines for any exceptions that occur while executing the statements in the try block.
Each catch block specifies the type of exception that it handles in a parameter list.
An optional finally block can be added at the end of the catch blocks to provide a set of statements that are always executed whether or not an exception occurs.

6. FileNotFoundException InterruptedIOException
Exception Handling
The exception hierarchy (partial)
Exception
RunTimeException
DataFormatException
IOException
EOFException
FileNotFoundException
InterruptedIOException
NumberFormatException
All exceptions inherit from a base class Exception
Common Exception sub classes include:
IOException can be decomposed into specific classes of I/O errors
NumberFormatException is a subclass of DataFormatException

7. Exception Handling Example
Consider implementing the BufferReader readLine( ) example with try-catch clocks.
import java.io.*
public class ExceptionalExample {
public static void main(String [ ] args) //no throws clause used here {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
System.out.println(“Enter a number”);
try {
String str = br.readLine( );
double num = Double.parseDouble(str); }
try block encapsulates the readLine( ) method and the conversion from String to double.
Will throw NumberFormatException if str cannot be converted to a double.

8. Exception Handling Example (continued) //add the catch blocks
catch (IOException ioe) {
//print a message to the screen
System.out.println(ioe.toString( )); }
catch (Exception e) {
//catch any other exception and print a message to the screen
System.out.println(e.toString( ));
finally {
System.exit(0);
catch the IOException object thrown by readLine( )
Note! ioe is a handle (reference) to an IOException object thrown by readLine( )
Note! toString( ) is a method that all
Classes inherit (implicitly).
In the finally clause we ensure that the program terminates properly – exit(0) signifies normal termination.
Since both catch blocks have the same implementation in this example, there is no need to single out IOException in a separate block.

9. Exception Handling The anatomy of an exception
In the main( ) function of ExceptionalExample a BufferedReader object called br is created and attatcher to isr.
An error occurs while attempting to read from the keyboard. An IOException object is created.
br.readLine( ) is called inside of a try block in function main( )
ExceptionalExample
The IOException is passed to the catch block in function main( )
Message is sent to object referenced by ioe to execute its toString( ) method (inherited from implicit base class Object)
try {
String str =br.readLine( ); }
catch (IOException ioe){
System.out.println(ioe.toString()); }
br:BufferedReader
IOException
new
readLine( ) {..}
toString( ) {…}