Further Notes on Exceptions

Problem: How can we elegantly deal with errors?

Traditional approaches to error handling involve testing the return value of a method
In many cases we can use boolean return values, or null if a method returns an object
However, in some cases, there might be different types of error
e.g. a method which reads data from file could return 0 for success, or 1 and 2 for different types of error (e.g. file doesn't exist, or hard drive is corrupted)
However this might make our code rather hard to read and understand

Answer: Use exceptions!

We can handle the errors by the use of exceptions
When we encounter an error, we throw an exception
An exception is a special object which is generated when the error occurs
We then catch the exception in the calling code

Exceptions

Example of throwing an exception

Imagine a CD class, which has attributes of type (single or album), artist and title:

public class CD
{
    public void setDetails (String type, String title, String artist)
                    throws InvalidTypeException
    {
        if (type.equals("album") || type.equals("single"))
        {
            this.type = type;
            this.artist = artist;
            this.title = title;
        }
        else
        {
           throw new InvalidTypeException("Must be single or album!");
        }
    }
}

We throw an exception if the type is unrecognised i.e. not single or album
If the exception occurs, no code below the throw statement will run
Instead, we will return back to the calling code

Catching an exception

In order to handle the error, we need to catch any exception that we throw
To do that, we put the code which might generate the exception in a try/catch block

e.g.

String type = (read in from user)
String title = (read in from user)
String artist = (read in from user)

CD cd = new CD();

try
{
    cd.setDetails (type, title, artist);    
    System.out.println("Created CD successfully.");
}
catch (InvalidTypeException e)
{
    System.out.println ("An error occurred: " + e);
}

We try the code which might generate the exception (the setDetails() method) and catch any exceptions generated in the catch block
The code below the exception-generating method (setDetails) in the try block will not run if an exception occurred
- In other words, if there was an exception, the Created CD successfully method will not be displayed

What is an exception class?

What about the exception class (InvalidTypeException)?
It's an ordinary class which inherits from the standard library class Exception:
```
public class InvalidTypeException extends Exception
```
This allows us to use certain features common to all Exceptions
When we create the exception, we can store information about the exception within it

e.g. the Must be single or album! message:

throw new InvalidTypeException("Must be single or album!");

Example of an exception class

e.g.

public class InvalidTypeException extends Exception
{
    String message;

    public InvalidTypeException (String m)
    {
        message = m;
    }

    public String toString()
    {
        return message;
    }
}

Note how the toString() method returns the message associated with the exception

Built-in Exceptions

There are many built-in exception classes in Java
These include:
- ArithmeticException - an illegal mathematical operation, such as a division by zero, is performed
- ArrayIndexOutOfBoundsException - when we try to look up a member of an array outside the array bounds
- NumberFormatException - if we convert a non-number (e.g. a word) into a number using Integer.parseInt()
- NullPointerException - we try to do something with an object which has not been initialised, e.g.
```
    Person p = null; // SHOULD BE Person p = new Person(); !
    p.setName ("John");
    
```
- IOException (i.e. input/output exception) - some sort of error occurred when we try to write to or read from a file, or connect across a network. This could include, for example, the hard drive or USB stick that we are writing to being corrupted or full
- FileNotFoundException - a subclass of IOException, which is thrown if we try to access a non-existent file

The Exception Class Hierarchy

The Exception Hierarchy

The Exception class itself inherits from Throwable
- A Throwable is any object which can be thrown by a throw statement
- It is an error to put a class which is not a subclass of Throwable in a throw statement
- As well as Exception, the Error class inherits from Throwable: this represents system errors, e.g. running out of memory
RuntimeException (a subclass of Exception) is dealt with in the next slide

Checked and Unchecked Exceptions

Normally, exceptions must be caught
- Such exceptions are known as checked exceptions
The compiler will give an error if we do not catch an exception
However, if we inherit from RuntimeException we do not have to catch them
- RuntimeExceptions are also known as unchecked exceptions as we do not have to catch them

Unchecked Exceptions

Unchecked exceptions (subclasses of RuntimeException) do not have to be caught
Unchecked exceptions are thrown whenever you try to do something avoidable
Careful programming, typically using if statements to validate our data, can prevent such exceptions occurring
Therefore, it is silly to force the user to catch the exceptions
Examples of unchecked exceptions: NullPointerException, ArithmeticException (see above)
In both cases, we can guard against the error occurring:
- ArithmeticExceptions can be guarded against by checking in advance whether we are dividing by 0 (with an if statement)
- NullPointerExceptions can be guarded against by making sure you initialise all objects, or by checking whether the object is null

Checked Exceptions

All other exceptions are checked exceptions and must be caught
These exceptions typically cannot be guarded against by careful programming
One example could be connecting across a network to a remote machine (e.g. a multi-player game server, remote database, or web server)
- The network could go down at any time
- You cannot guard against this in advance
- So if the network fails, an exception is thrown and you handle it in your code there and then

Catching Different Types Of Exception

It is possible that code can throw different types of exception
If this happens, we should handle each type of exception in its own catch block

e.g. for reading in from a file, we could get a FileNotFoundException if the file does not exist, or, if a general error (such as a hard drive failure) occurs, we could get an IOException:

try
{
    // Not a real Java method - imagine this is a custom method we have written to
    // read in from file, hiding the complexities of file I/O
    readFromFile("myfile.dat");
}
catch (FileNotFoundException e)
{
    System.out.println("Input file myfile.dat could not be found!");
}
catch (IOException e)
{
    System.out.println("General input/output error - hard drive failure?");
}

We catch the FileNotFoundException to handle the specified file not existing
Then we catch the IOException to handle any other input/output errors, e.g. hard drive failure

Order of catching multiple exceptions

If more than one catch block matches an exception...
- e.g. for a FileNotFoundException, both the catch(FileNotFoundException e) and the catch (IOException e) match, as FileNotFoundException is a subclass of IOException
the first catch block in the code is run in preference
So, always put the catch blocks to handle the more specific exceptions first in your code
- More specific exceptions (e.g. FileNotFoundException) will likely require special treatment
a final
```
catch (Exception e)
```
will catch any exceptions not caught by the more specific catch blocks above

e.g.

try
{
    ....
}
catch (VerySpecificException e)
{ 
    ...
}
catch (MoreGeneralException e)
{
    ....
}
catch (Exception e)
{
    ....
}

Getting information about an exception

There are two built-in methods for getting information about an exception:
- getMessage() - displays the message associated with an exception
- printStackTrace() - displays where in your program the exception occurred

finally

A try/catch block can have an optional finally block
A finally block always runs, whether or not an exception occurred
It's typically used for cleanup operations such as closing a connection to a database

e.g:

DatabaseConnection connection = null;
try
{
    connection.connect(username, password);
    Results results = connection.query("SELECT * FROM songs");
    // do something with the database results (not shown)
}
catch(DatabaseException sqlException)
{
    out.println("Error: " + sqlException);
}
finally
{
    if(connection != null)
    {
        connection.close();
    }
}

We need to close the database connection whether or not an exception occurred while reading data from the database

Further Notes on Exceptions

Credits for these notes

Exceptions

Problem: How can we elegantly deal with errors?

Answer: Use exceptions!

Example of throwing an exception

Catching an exception

What is an exception class?

Example of an exception class

Built-in Exceptions

The Exception Class Hierarchy

Checked and Unchecked Exceptions

Unchecked Exceptions

Checked Exceptions

Catching Different Types Of Exception

Order of catching multiple exceptions

Getting information about an exception

finally