1. Java Exception Dept. Business Computing University of Winnipeg
Yangjun Chen
Dept. Business Computing
University of Winnipeg
Jan. 2004

2. Outline: Exceptions Exceptions Managing Exceptions
try and catch blocks
finally clause
Exception propagation
Throwing Exceptions
Creating your own Exceptions
Jan. 2004

3. exception propagation
Outline: Exceptions
Catching
exception:
Reporting
exception:
Creating
exception:
try { … }
public boolean myM(int x)
throws AnException { …
throw new AnException(); }
public class A extends
Exception { … }
catch { … }
finally { … }
exception propagation
Jan. 2004

4. Exceptions Exceptions are unusual things that happen within your Java
program that are different from the desired behavior of the
program.
They could be fatal errors or could be in the event of
exceptional circumstances.
Exception handling is the management of these exceptions or errors.
When an exception is encountered, Java will report this
problem by throwing an exception.
Jan. 2004

5. Exceptions
At this point, the system will halt normal operation and look for a solution to the problem. It looks in your code, to see if there is anything that will catch the exception.
After the exception is caught, normal operation is resumed
after the offending block of code.
In traditional error handling, some code is usually written
to head off the error before it occurs.
Exception handling in Java allows the error or unusual
situation to occur and then takes steps to deal with it.
Exceptions don’t occur in Java. They are thrown.
Exceptions can be thrown by either the system or by the
programmer.
Jan. 2004

6. Exceptions
Exceptions in Java are actual objects of classes that inherit
from the Throwable class.
ArithmeticException
RuntimeException
ArrayStoreException
… ...
ClassNotFoundException
Exception
Error
NoSuchFieldException
NoSuchMethodException
… ...
Throwable
OutOfMemoryError
StackOverflowError
… ...
VirtualMachineError
LinkageError
ClassFormatError
ThreadDeath
NoClassDefFoundError
… ...
Jan. 2004

7. Throwable Class The Throwable class has two subclasses: Error and
Exception .
Instances of the Error class represent internal errors that are
usually fatal. You can neither catch them nor throw them
yourself.
The Exception subclass will contain most of the exception
classes that are used, but there are other packages that
define their own exception classes.
- For example, the java. io package has its own exception class
called IOException .
So how do we handle exceptions?
Jan. 2004

8. Managing Exceptions
The Java compiler will enforce exception management
when you try to use methods that declare exceptions. Your
program will not compile unless there is code that will
handle the exception.
Handling or catching an exception requires two things:
- protecting the code that contains the method that throws an
exception by putting it inside a try block
- Testing and dealing with the exception in a catch block
What these two keywords mean is to “try this code that
might cause an exception. If all works well, then continue
on. If it doesn’t, then catch the problem and deal with it.”
For example, let’s look at the following code.
Jan. 2004

9. Try and Catch
All try blocks must have a catch block associated with it.
You can also have more than one catch clause associated
with each try block.
try {
offset = x / n;
// anything from here down will be ignored if n is 0. }
catch (ArithmeticException e){
offset = 10;
// Execution will continue from here after the exception is
// handled
Jan. 2004

10. Multiple Catch Clauses
catch clauses are examined from top to bottom, stopping at
the first clause that has an argument that is compatible with
the thrown exception and then skipping the remaining
clauses.
try { … }
catch (Exception e) { // Compatible with every exception
catch (ArithmeticException e) { // will never be called
Jan. 2004

11. finally Clause Suppose that there is some code that must be executed
whether an exception was thrown or not.
This is done in what is called the finally clause.
SomeFileClass f = new SomeFileClass();
if (f. open(“/ a/ file/ name/ path”)) {
try {
someReallyExceptionalMethod();
} catch (IOException e) {
// deal with them!!
} finally {
f. close();
}//finally
}//if
Jan. 2004

12. finally Clause
Instead of using the finally clause, you could put the code
in all the catch clauses as well as just outside them, but this
would be duplicating code.
A try block can have at most one finally clause and it must
appear immediately after the last catch clause.
If a try block has a finally clause, it does not have to have
any catch clauses.
As with catch, a finally clause must be associated with a try
block.
Jan. 2004

13. Exception Propagation
Exceptions are propagated if there isn’t a catch clause
associated with the try block that has a compatible
exception type.
The system will then look for an enclosing try.. catch pair
that has an appropriate catch clause.
try { …
try { // exception thrown here }
catch (SomeException e) { // exception not caught here }
catch (SomeOtherException e) { // look here
Jan. 2004

14. Exception Propagation
If an appropriate catch clause is not found, the search
continues until it reaches the block which encloses the
entire method body.
If there is still no compatible catch clause, the search is
widened to include the block containing the method call.
This search continues on outward, until eventually the
exception is handled. If there doesn’t exist any handling
for the exception, the Java environment will handle it for
you. Java will terminate you program!
This isn’t always a bad idea. There are situations that
terminating the program will be better or is the only
alternative.
Jan. 2004

15. The throws Clause
To indicate that some code in the body of your method may
throw an exception, use the throws keyword after the
signature of the method.
- public boolean myMethod( int x) throws AnException { … }
For multiple exception types, put them all in the throws
clause separated by commas.
You can also throw a superclass of a group of exceptions to
indicate that your method may throw any subclass of that
exception.
- public void myMethod2( int x) throws IOException { … }
Exceptions of either class Error or RuntimeException do
not have to be included in the throws clause. Java gives
them special treatment. They are implicit exceptions.
Jan. 2004

16. The throws Clause
Declaring that your method throws an exception doesn’t
actually make your method throw the exception if occurred.
This has to be done within the body of the method itself.
To throw an exception, an instance of some exception class
is needed. Once an instance is created or obtained, use the
throw statement to throw it.
Jan. 2004

17. The throws Clause
The simplest way is to create the instance and throw the
exception in the same statement.
- throw new ServiceNotAvailableException();
You can only throw objects that are instances of subclasses
of Throwable unlike in C++ where an object of any type
may be thrown.
Depending on the exception class that you are using, the
exception’s constructor may require some arguments. The
most common argument is a string that describes the
exception in more detail.
- throw new ServiceNotAvailableException(“ Exception:
service not available, database is offline.”);
Jan. 2004

18. The throws Clause Once an exception is thrown, the method exits after
executing the finally clause (if one exists) without returning
a value.
The exception is then passed on to the surrounding
try.. catch block and propagated further until it is handled.
Jan. 2004

19. Creating Exceptions
Although Java provides a wealth of exception classes, there
may be times where we would like to create our own
exceptions that are not covered by the predefined exception
classes.
To create a exception, you must inherit from one of the
other exception classes. Try to find an exception that’s
close to the one you are creating.
If none of the exceptions match closely, then inherit from
Exception itself which is the top of the hierarchy for
explicit exceptions or RuntimeException.
Exception classes typically have two constructors, one with
no arguments and one with a string argument.
Jan. 2004

20. Creating Exceptions
The MissingData exception is thrown in a utility method.
class MissingData extends Exception {
// thrown by the processSubmitButton() when one or more of the
// data fields are empty
public MissingData() {
super(); }
public MissingData( String s) {
super(s);
Jan. 2004

21. Creating Exceptions
private void processSubmitButton() throws MissingData {
if (( custName. getText(). equals( EMPTY)) ||
(custStreet. getText(). equals( EMPTY) ||
//( six more clauses omitted here)
(order. getText(). equals( EMPTY))) {
throw new MissingData(“ Complete all fields!”); }
else { // Data is all there
order. appendText( CRLF+” ORDER PLACED”);
repaint();
}//else
}// processSubmitButton
Jan. 2004

22. Creating Exceptions
Note that we have to use a throws clause, since MissingData is a checked exception.
Now the exception is caught in the applets action() handler. …
else if (e. target == Submit) {
try {
processSubmitButton(); }
catch (MissingData ex) {
order.appendText(“* ”+ ex.getMessage()+ CRLF);
repaint();
return true;
Jan. 2004

23. An Example for Exception Propagation
import java.lang.*;
//Here we define some exception types of our own.
//Exception classes generally have constructors but no data or
//other methods. All these do is call their superclass constructors.
class MyException extends Exception {
public MyException() {super();}
public MyException(String s) { super(s); } }
class MyOtherException extends Exception {
public MyOtherException { super();}
public MyOtherException(String s) { super(s); }
Jan. 2004

24. An Example for Exception Propagation
class MySubException extends MyException {
public MySubException() { super(); }
public MySubException(String s) { super(s); } }
public class Throwtest {
//This is the main() method. Note that it uses two
//catch clauses to handle two standard Java exceptions.
public static void main(String argv[]) {
int i = 2;
Jan. 2004

25. An Example for Exception Propagation
//First, covert our argument to an integer.
//Make sure we have an argument and that it is convertible.
try { i = Integer.parseInt(argv[0]; }
catch (ArrayIndexOutOfBoundsException e) {//argv is empty
System.out.println("Must specify an argument");
return; }
catch (NumberFormatException e) {//argv[0] is not an integer
System.out.println("Must specify an integer argument");
Jan. 2004

26. An Example for Exception Propagation
//Now, oass that integer to method a().
a(i); }
//This method invokes b(), which is declared to throw
//one type of exception. We handle that one exception.
public static void a(int i) {
try {
b(i);
Jan. 2004

27. An Example for Exception Propagation
catch (MyException e) { //Point 1
//Here we handle MyException and its subclass MySubException
if (e instanceof MySubException)
System.out.print("MySubException: ");
else
System.out.print("MyException: ");
System.out.println(e.getMessage());
System.out.println("Handle at point 1"); }
Jan. 2004

28. An Example for Exception Propagation
public static void b(int i) throws MyException {
int result;
try {
System.out.print("i = " + i);
result = c(i);
System.out.print(" c(i) = " + result); }
catch (MyOtherException e) { //Point 2
//Handle MyOtherException:
System.out.println("MyOtherException: " + e.getMessage());
System.out.println("Handle at point 2");
Jan. 2004

29. An Example for Exception Propagation
finally {
//Terminate the output we printed above with a newline.
System.out.print("\n"); }}
public static int c(int i) throws MyException, MyOtherException {
switch (i) {
case 0: //processing resumes at point 1 above
throw new MyException("input too low");
case 1: //processing resumes at point 1 above
throw new MyException("input still too low");
case 99: //processing resumes at point 2 above
throw new MyOtherException("input too high");
default:
return i*i;}}}
Jan. 2004