Java Fundamentals Tutorial: Exceptions

Exceptions are used to indicate many different types of error conditions.

System errors:

In a traditional programming language like C, an error condition is usually indicated using an integer return value (e.g. -1 for out of memory). However, this practice:

public class ExceptionDemo {

    public static void main (String[] args) {
        System.out.println(divideArray(args));
    }

    private static int divideArray(String[] array) {
        String s1 = array[0];
        String s2 = array[1];
        return divideStrings(s1, s2);
    }

    private static int divideStrings(String s1, String s2) {
        int i1 = Integer.parseInt(s1);
        int i2 = Integer.parseInt(s2);
        return divideInts(i1, i2);
    }

    private static int divideInts(int i1, int i2) {
        return i1 / i2;
    }
}

Compile and try executing the program as follows:

java ExceptionDemo 100 4
java ExceptionDemo 100 0
java ExceptionDemo 100 four
java ExceptionDemo 100

Note that we could have overloaded all divide*() methods (since they have different parameters), but this way the generated stack traces are easier to follow.

Figure 7. A Sample of Exception Types

All exceptions and errors extend from a common java.lang.Throwable parent class. Only Throwable objects can be thrown and caught.

Other classes that have special meaning in Java are java.lang.Error (JVM Error), java.lang.Exception (System Error), and java.lang.RuntimeException (Programming Error).

public class java.lang.Throwable extends Object
            implements java.io.Serializable {
    public Throwable();
    public Throwable(String msg);
    public Throwable(String msg, Throwable cause);
    public Throwable(Throwable cause);
    public String getMessage();
    public String getLocalizedMessage();
    public Throwable getCause();
    public Throwable initCause(Throwable cause);
    public String toString();
    public void printStackTrace();
    public void printStackTrace(java.io.PrintStream);
    public void printStackTrace(java.io.PrintWriter);
    public Throwable fillInStackTrace();
    public StackTraceElement[] getStackTrace();
    public void setStackTrace(StackTraceElement[] stackTrace);
}

There is a lot of controversy around checked vs. unchecked exceptions.

Checked exceptions give API designers the power to force programmers to deal with the exceptions. API designers expect programmers to be able to reasonably recover from those exceptions, even if that just means logging the exceptions and/or returning error messages to the users.

Unchecked exceptions give programmers the power to ignore exceptions that they cannot recover from, and only handle the ones they can. This leads to less clutter. However, many programmers simply ignore unchecked exceptions, because they are by default un-recoverable. Turning all exceptions into the unchecked type would likely lead to poor overall error handling.

It is interesting to note that Microsoft’s C# programming language (largely based on Java) does not have a concept of checked exceptions. All exception handling is purely optional.

For example:

java ExceptionDemo 100 0

Exception in thread "main" java.lang.ArithmeticException: / by zero
at ExceptionDemo.divideInts(ExceptionDemo.java:21)
at ExceptionDemo.divideStrings(ExceptionDemo.java:17)
at ExceptionDemo.divideArray(ExceptionDemo.java:10)
at ExceptionDemo.main(ExceptionDemo.java:4)

Looking at the list bottom-up, we see the methods that are being called from main() all the way up to the one that resulted in the exception condition. Next to each method is the line number where that method calls into the next method, or in the case of the last one, throws the exception.

Figure 8. The `try-catch-finally` Control Structure

public class ExceptionDemo {

    public static void main (String[] args) {
       divideSafely(args);
    }

    private static void divideSafely(String[] array) {
        try {
            System.out.println(divideArray(array));
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Usage: ExceptionDemo <num1> <num2>");
        } catch (NumberFormatException e) {
            System.err.println("Args must be integers");
        } catch (ArithmeticException e) {
            System.err.println("Cannot divide by zero");
        }
    }

    private static int divideArray(String[] array) {
        String s1 = array[0];
        String s2 = array[1];
        return divideStrings(s1, s2);
    }

    private static int divideStrings(String s1, String s2) {
        int i1 = Integer.parseInt(s1);
        int i2 = Integer.parseInt(s2);
        return divideInts(i1, i2);
    }

    private static int divideInts(int i1, int i2) {
        return i1 / i2;
    }
}

public class ExceptionDemo {

    public static void main (String[] args) {
       divideSafely(args);
    }

    private static void divideSafely(String[] array) {
        try {
            System.out.println(divideArray(array));
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Usage: ExceptionDemo <num1> <num2>");
        }
    }

    private static int divideArray(String[] array) {
        String s1 = array[0];
        String s2 = array[1];
        return divideStrings(s1, s2);
    }

    private static int divideStrings(String s1, String s2) {
        try {
            int i1 = Integer.parseInt(s1);
            int i2 = Integer.parseInt(s2);
            return divideInts(i1, i2);
        } catch (NumberFormatException e) {
            return 0;
        }
    }

    private static int divideInts(int i1, int i2) {
        try {
            return i1 / i2;
        } catch (ArithmeticException e) {
            return 0;
        }
    }
}

	Caution
	Be careful about being too generic in the types of exceptions you catch. You might end up catching an exception you didn’t know would be thrown and end up “hiding” programming errors you weren’t aware of.

public class ExceptionDemo {

    public static void main (String[] args) {
       divideSafely(args);
    }

    private static void divideSafely(String[] array) {
        try {
            System.out.println(divideArray(array));
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Usage: ExceptionDemo <num1> <num2>");
        } catch (RuntimeException e) {
            System.err.println("Error result: 0");
        }
    }

    private static int divideArray(String[] array) {
        String s1 = array[0];
        String s2 = array[1];
        return divideStrings(s1, s2);
    }

    private static int divideStrings(String s1, String s2) {
        int i1 = Integer.parseInt(s1);
        int i2 = Integer.parseInt(s2);
        return divideInts(i1, i2);
    }

    private static int divideInts(int i1, int i2) {
        return i1 / i2;
    }
}

Some of the more commonly used exception types are:

For example:

/**
* Circle shape
*/
public class Circle implements Shape {
    private final double radius;
    /**
    * Constructor.
    * @param radius the radius of the circle.
    * @throws IllegalArgumentException if radius is negative.
    */
    public Circle(double radius) {
        if (radius < 0.0) {
            throw new IllegalArgumentException("Radius " + radius
                + " cannot be negative");
        }
        this.radius = radius;
    }
    …
}

/**
 * Exception thrown to indicate that there is insufficient
 * balance in a bank account.
 * @author me
 * @version 1.0
 */
public class InsufficientBalanceException extends Exception {
    private final double available;
    private final double required;

    /**
     * Constructor.
     * @param available available account balance
     * @param required required account balance
     */
    public InsufficientBalanceException(double available, double required) {
        super("Available $"+available+" but required $"+required);
        this.available = available;
        this.required = required;
    }

    /**
     * Get available account balance
     * @return available account balance
     */
    public double getAvailable() {
        return available;
    }

    /**
     * Get required account balance
     * @return required account balance
     */
    public double getRequired() {
        return required;
    }

    /**
     * Get the difference between required and available account balances
     * @return required - available
     */
    public double getDifference() {
        return required - available;
    }
}

public Customer getCustomer(String id) throws DataAccessException {
    try {
        Connection con = this.connectionFactory.getConnection();
        try {
            String sql
                = "SELECT * FROM Customers WHERE CustomerID='"
                + id + "'";
            PreparedStatement stmt = con.prepareStatement(sql);
            try {
                ResultSet result = stmt.executeQuery(sql);
                try {
                    return result.next() ? this.readCustomer(result) : null;
                } finally {
                    result.close();
                }
            } finally {
                stmt.close();
            }
        } finally {
            con.close();
        }
    } catch (SQLException e) {
        throw new DataAccessException("Failed to get customer ["
                        + id + "]: " + e.getMessage(), e);
    }
}

Observe that the getCustomer() method signature does not say anything about customers being retrieved from a SQL-based RDBMS. This allows us to provide an alternative implementation, say based on a LDAP directory server or XML files.