An Introduction to Java Programming and Object-Oriented Application Development

Chapter 8Exceptions and Assertions

Objectives

In this chapter you will: Explore how Java throws and catches exceptions Become familiar with many of Java’s exception

classes Take a first look at the concept of inheritance Write code that handles exceptions thrown by a

Java program Create assertions to debug a program

Exceptions and Assertions

Applications should be robust, or well constructed Applications should be fault tolerant, or forgiving

of user mistakes Compile-time errors are violations of the

programming language syntax Runtime errors occur during program execution

and can cause a program to crash Logic errors produce incorrect output

Exception Handling

Runtime errors are referred to as exceptions When Java creates an exception object, it

throws the exception for further processing Two ways to handle exceptions

Do nothing: Let the Java runtime system handle it Write additional code to handle the exception

Handling the exception is preferable

An Example of a Thrown Exception The error message produced by Java when an

exception is thrown is the stack trace The method-call stack is the sequence of method

calls that leads to creation of exception

An Example of a Thrown Exception (continued)

An Example of a Thrown Exception (continued) The exception was created in Line 48 of

NumberFormatException.java The method-call stack steps through each call to

a method, originating in Line 15 of main The stack trace gives a complete description of

the NumberFormatException object One option is to add logic to allow the user to

enter a greater variety of input

An Example of a Thrown Exception (continued) When an exception is thrown, the Java runtime

system looks for code to handle the exception The method-call stack is checked for this code If no such code exists, the exception object is printed

and the program terminates If the exception were handled by the programmer,

the code could exit more gracefully The user could correct mistakes before the program

exited

Handling Errors with Program Logic User input can be checked for validity using

additional logic As programs become more complex, handling

errors with additional logic becomes more complicated

Adding logic may make the program less readable Adding logic may make the program more difficult

to maintain

Handling Exceptions with the try Statement Catching exceptions allows for customized

error statements The user can correct mistakes without

restarting the program The programmer needs three tools

The try blockThe catch blockThe finally block

Handling Exceptions with the try Statement (continued) A try block begins with the keyword try

Contains statements where exceptions originate Contains statements that should normally execute

If an exception occurs, the rest of the try block is skipped

If an exception occurs, program control goes to the first catch block following the try block

Handling Exceptions with the try Statement (continued) For each try block there is one or more catch

blocks There is one catch block for each type of

exception thrown A catch block begins with the keyword catch

and the exception parameter in parentheses When an exception is thrown, if a catch block

matches the exception type, it is executed

Handling Exceptions with the try Statement (continued) After the catch block is executed, program

control continues after the last catch block An uncaught exception is handled by the Java

runtime system The object’s stack trace is displayed The program terminates

If no exceptions are thrown, the program skips all catch and finally blocks and processing continues normally

Handling Exceptions with the try Statement (continued) The finally block is a set of statements

that always executesUseful for tasks like closing files

A try statement is the try, catch and finally blocks

e is the customary identifier for an exception object

Handling Exceptions with the try Statement (continued) try statement syntax:try {

normal program statements } catch (TypeOfException_1 e) {

statements to process this exception } … catch (Type of Exception_n e) {

statements to process this exception } finally {

statements that always execute }

Handling Exceptions with the try Statement (continued) If a try statement is added to a program, a catch

statement must also be added Each catch statement handles one type of

exception A catch block executes only if an exception of the

specified type is thrown within the try block A finally block can be added immediately after

a try block or a combination of try and catch blocks

Classifying Exceptions

Exceptions can be classified according to an inheritance hierarchy

Exceptions can be classified as checked or unchecked

An inheritance hierarchy is like a taxonomy, a classification scheme according to common and unique characteristics

A subclass inherits from the class above it A superclass is above a subclass

Classifying Exceptions (continued)

Classifying Exceptions (continued) An unchecked exception inherits from the RuntimeException class

All other exception classes are checked Checked exceptions cause compiler errors if they are

not handled Unchecked exceptions do not cause compile-time

errors, but may cause runtime errors A throws clause follows the method declaration

throws TypeOfException1,TypeOfException2…

Multiple Catch Blocks and Programmer-Defined Exceptions The types of exceptions that can be thrown are

discovered through extensive testing catch blocks must immediately follow try

blocks with no intervening code A catch block for a more specific type of

exception should precede more general types Can use an IllegalArgumentException for

exception types not previously defined in Java An Exception object can also be used, but it is

poor programming practice

Propagating Exceptions

An exception propagator is a method that originates an exception

An exception catcher is the method that catches the exception

If an exception originates in a method but is not caught, the exception propagates up the method-call stack

The method-call stack is the sequence of method calls

Propagating Exceptions (continued)

Apply the Concept

The application divides two numbers, and is simple to showcase exception handling

A boolean flag thereIsAnError signals that an error or exception has occurred

Three methods are called in a while loop getDividend getDivisor calculateAndDisplay

The while loop executes while thereIsAnError is true

Apply the Concept (continued)

Exceptions are caught if the user terminates the application prematurely

Exceptions are caught if the user enters letters instead of digits

Exceptions originating in getDividend and getDivisor propagate to main

The method calculateAndDisplay catches an IllegalArgumentException if the divisor is zero

Apply the Concept (continued)

Apply the Concept (continued)

Assertions

Three major types of errorsCompile-time errorsRuntime errorsLogic errors

Compile-time errors are the result of syntax errors Runtime errors cause the program to terminate

while running Logic errors cause incorrect output

Using an Assertion

An assertion is designed to help the programmer detect logic errors

The syntax of an assert statement:assert expression : error message

The expression is a boolean expression that should always be true if the program is working

The error message is displayed if the expression ever becomes false

Assertions are placed after all values in expression have been determined

An Example of an Assertion

An assert statement is placed to verify that kilograms are less than pounds

If the assertion is false, an AssertionError is thrown

The custom error is optional, but useful Compile with the –source 1.5 option Run with assertions enabled: -ea

An Example of an Assertion (continued)

Summary

Programs can be made more robust and fault tolerant using exception handling

Exceptions are handled using a try statement The try statement consists of a try block, a catch block, and an optional finally block

Exceptions can be classified according to the inheritance hierarchy, or as checked or unchecked

The inheritance hierarchy is a taxonomy of Java classes

Summary (continued)

A subclass inherits from the class just above it The superclass is the class just above a given

class in the hierarchy Unchecked exceptions inherit from the RuntimeException class

All other exceptions are checked Checked exceptions must be handled or the

program will not compile

Summary (continued)

Must be one catch block for every try block Each catch block handles one type of

exception Multiple catch blocks may follow a try block Exceptions that are not caught are propagated

up the method-call stack An assertion can be used to guarantee that

programmers don’t make major logic errors