Title: Exception Handling
1Exception Handling
2Introduction
- A program can be written assuming that nothing
unusual or incorrect will happen. - Unfortunately, it isnt always so.
- You should add Javas exception-handling
facilities to accommodate the unusual, unexpected
case(s).
3When You Execute a System
- You get a correct result from the system.
- You get an incorrect result.
- The system crashes.
- The system hangs up.
4Causes for System Failures
- Programming errors
- Invalid inputs
- Unusually heavy stress or load
- Memory leaks
- ..
- ..
5Program Correctness
- 63000 known bugs in
- ? Programs that have not been shown to be correct
can still be, and are, useful.
6Correctness vs. Reliability
- A partially incorrect program which can
continuously operates is sometimes regarded
higher than a correct program may fail.
7Introduction, cont.
- Exception handling divides a class or method
definition into separate sections - one section for the normal case(s)
- another section for the exceptional case(s).
- Depending on how a method is used, special cases
may need to be handled in different ways. - Sometimes an exception needs to be thrown to
handle a problem outside the method.
8Basic Exception Handling Outline
- Exceptions in Java
- Predefined Exception Classes
9Exception Handling
- Either your code or Java signals when something
unusual happens. - The signaling process is called throwing an
exception. - Somewhere in your program, you can place code to
handle the exception.
10Exceptions in Java Example
- calculate donutCount / milkCount
- if milkCount0, the divide by zero exception
occurs - you can check this condition with if-statement
- Or, it is also possible to throw an exception.
11(No Transcript)
12Exceptions in Java Example, cont.
13The catch Block
- The class name preceding the catch-block
parameter specifies what kind of exception the
catch block can catch. - Class name Exception permits any exception to be
caught. - The catch-block parameter provides a name for the
exception that is caught, to permit the exception
object to be used subsequently.
14The catch Block, cont.
- If the program cannot recover from the exception,
the catch block can include - System.exit(0)
15method getMessage
- Every exception has a method called getMessage.
- By default, this method retrieves the string
given to the constructor of the exception object.
16method getMessage, cont.
17try-throw-catch
- The try-throw-catch threesome is similar to an
if-else statement. - However, an object of the class Exception is
created and its message can be carried by the
thrown exception, providing more versatility than
an if-else statement
18Predefined Exception Classes
- Some methods in predefined classes can throw
predefined exceptions. - An invocation of such a predefined method can be
included in a try block and followed by a catch
block. - some predefined exceptions
- IOException
- ClassNotFoundException
- FileNotFoundException
19Predefined Exception Classes, cont.
- Class Exception is the root class of all
exceptions. - However, an exception typically is handled more
appropriately by one of its descendants. - The string returned by a predefined exception
typically provides enough information to
identify the source of the exception.
20ArrayOutOfBoundsException
- When a program attempts to use an array index
that is out of bounds, an ArrayOutOfBoundsExceptio
n is thrown. - The program ends unless the exception is caught
in a catch block. - An ArrayOutOfBoundsException usually indicates a
code error rather than an exception that should
be caught.
21Defining Exception Classes
- You can define your own exception classes, but
they must be derived from an existing exception
class. - Constructors are the most important, and often
the only methods (except for methods inherited
from the base class).
22Defining Exception Classes, cont.
- class DivideByZeroException
23Defining Exception Classes, cont.
24Defining Exception Classes, cont.
25Defining Exception Classes, cont.
26Java Tip Preserve getMessage
- For all predefined exception classes, method
getMessage returns either - the string that is passed as an argument to the
constructor or - a default string if no argument is passed to the
constructor. - The behavior of method getMessage should be
preserved in any exception class you define.
27Preserve getMessage, cont.
- This is done by including a string parameter that
begins with a call to super. - public MyException(String message)
-
- super(message)
- More_Code_If_Appropriate
28Preserve getMessage, cont.
- Also include a default constructor.
- public MyException()
-
- super(MyException thrown)
- More_Code_If_Appropriate
-
29Programming Tip When to Define an Exception Class
- In general, define an exception class if you are
going to insert a throw statement in your code. - This permits catch blocks to distinguish between
your exceptions and exceptions thrown by
predefined methods.
30Guidelines
- Use class Exception as the base class unless
there is a compelling reason to do otherwise. - Define at least two constructors. Typically, no
other methods are needed. - Begin each constructor definition with a call to
the constructor of the base class.
31Guidelines, cont.
- Include a default constructor in which the call
to super has a string argument indicating the
kind of exception. - The string can be recovered using the getMessage
method. - Include a constructor that takes a single string
argument used in the call to super. - The string can be recovered with a call to
getMessage.
32Using Exception Classes Outline
- Declaring Exceptions (Passing the Buck)
- Exceptions That Need Not Be Caught
- (optional) The AssertionError Class
- Multiple Throws and Catches
- (optional) The finally Block
- (optional) Rethrowing an Exception
33Declaring Exceptions (Passing the Buck)
- Sometimes is it appropriate to handle an
exception other than in the method where the
exception occurred. - For example, it might be better to handle the
exception in the method that called the method
that threw the exception
34Declaring Exceptions, cont.
- If a method can throw an exception but does not
catch it, it must alert the programmer to the
possibility of an exception by including a throws
clause. - Example
- public void someMethod()
- throws DivideByZeroException
35Accounting for Exceptions
- An exception can be caught in a catch block
within a method definition. - Alternatively, the possibility of an exception
can be declared at the start of the method
definition by placing the exception-class name in
a throws clause. - These two approaches can be mixed in a method,
catching some exceptions and declaring others in
a throws clause.
36Accounting for Exceptions, cont.
- If method_A uses a throws clause instead of
handling an exception and method_B calls
method_A, then method_B either must handle the
exception or must also include a throws clause.
37 38Accounting for Exceptions, cont.
- A throws clause can include more than one
exception type. - example
- public int someMethod()throws
- IOException, DivideByZeroException
39Accounting for Exceptions, cont.
- Some method in the calling hierarchy should
handle the exception. - If an exception is thrown, but never caught,
either the program terminates or its behavior
becomes unreliable.
40Exceptions That Need Not Be Caught
- Some exceptions do not need to be accounted for
in any way. - (Perhaps these are the exceptions that prove the
rule about needing to account for exceptions.) - Exceptions that do not need to be accounted for
result from errors and usually are thrown by
methods in predefined classes.
41Exceptions That Need Not Be Caught, cont.
- Exceptions that derive from the class Error or
the class RunTimeException do not need to be
accounted for. - examples
- NoSuchMethodError
- OutOfMemoryError
- Adding a catch clause or passing the buck will
not solve the problem.
42Exceptions That Need Not Be Caught, cont.
- In the event you fail to account for some
exception that Java requires you to account for,
the compiler will alert you.
43throws Clauses in Derived Classes
- When a method is redefined in a derived class,
the redefined method cannot contain any exception
classes that are not in the throws clause of the
same method in the base class (though the derived
class can list fewer exceptions in its throws
clause). - Any exceptions thrown in the derived class must
be caught or thrown by the base class.
44The AssertionError Class
- If your program contains an assertion check and
the assertion check fails, the program may
terminate with an error message. - An exception of the class AssertionError is
thrown. - If it is not caught in a catch block (which is
typical), the program will terminate.
45Multiple Throws and Catches
- A try block can throw any number of different
types of exceptions. - Each catch block can catch only one type of
exception. - Multiple catch blocks after a try block can catch
multiple types of exceptions.
46Multiple Throws and Catches, cont.
47Multiple Throws and Catches, cont.
48Multiple Throws and Catches, cont.
49Multiple Throws and Catches, cont.
50Multiple Throws and Catches, cont.
- class NegativeNumbersException
51Java Tip Catch the More Specific Exceptions First
- catch blocks are examined in order.
- The first matching catch block is executed.
- More specific exceptions should precede less
specific exceptions, i.e. exceptions lower in the
exception hierarchy should come before exceptions
higher in the exception hierarchy.
52Programming Tip Exception Handling and
Information Hiding
- A method invocation can throw an exception that
is declared in its throws clause. - But, it does not matter where in the method
definition the throw statement is located. - The fact that it might throw an exception is all
that matters.
53Keep It Simple
- Attempt to modify a program or class definition
so that it does now need a throw statement. - In general, use exceptions sparingly.
- If the way the exception is handled depends on
the calling method, let the calling method handle
the exception. - Consider throwing the exception and catching the
exception in separate methods.
54Keep It Simple, cont.
- public void methodB()
-
- ...
- try
-
- ...
- methodA()
- ...
-
- catch (MyException e)
- ...
55Nested try-catch Blocks
- Inner try-catch blocks should be placed inside a
method definition, with the method invocation in
an outer try-catch block. - If an inner try-catch block is placed inside an
outer try-catch block, the catch-block parameters
in the inner and outer blocks must have different
names.
56Nested try-catch Blocks, cont.
- If an inner try block and its catch block are
placed inside an outer try block and an exception
is thrown in the inner try block, but not caught
by the inner catch block, the exception is
propagated to the outer try block and might be
caught by an outer catch block.
57The finally Block
- A finally block can be added after a try block
and its catch blocks. - The finally block is always executed no matter
- if the try block throws no exceptions
- if the try block throws an exception which is
caught by a catch block - if an exception is thrown but not caught
58The finally Block, cont.
- syntax
- try
-
-
-
- catch Block(s)
- finally
-
-