Exception Handling - PowerPoint PPT Presentation

1 / 58
About This Presentation
Title:

Exception Handling

Description:

Exceptions That Need Not Be Caught, cont. ... Any exceptions thrown in the derived class must be caught or thrown by the base class. ... – PowerPoint PPT presentation

Number of Views:96
Avg rating:3.0/5.0
Slides: 59
Provided by: robertp6
Category:

less

Transcript and Presenter's Notes

Title: Exception Handling


1
Exception Handling
  • Chapter 8

2
Introduction
  • 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).

3
When You Execute a System
  • You get a correct result from the system.
  • You get an incorrect result.
  • The system crashes.
  • The system hangs up.

4
Causes for System Failures
  • Programming errors
  • Invalid inputs
  • Unusually heavy stress or load
  • Memory leaks
  • ..
  • ..

5
Program Correctness
  • 63000 known bugs in
  • ? Programs that have not been shown to be correct
    can still be, and are, useful.

6
Correctness vs. Reliability
  • A partially incorrect program which can
    continuously operates is sometimes regarded
    higher than a correct program may fail.

7
Introduction, 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.

8
Basic Exception Handling Outline
  • Exceptions in Java
  • Predefined Exception Classes

9
Exception 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.

10
Exceptions 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)
12
Exceptions in Java Example, cont.
13
The 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.

14
The catch Block, cont.
  • If the program cannot recover from the exception,
    the catch block can include
  • System.exit(0)

15
method getMessage
  • Every exception has a method called getMessage.
  • By default, this method retrieves the string
    given to the constructor of the exception object.

16
method getMessage, cont.
17
try-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

18
Predefined 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

19
Predefined 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.

20
ArrayOutOfBoundsException
  • 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.

21
Defining 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).

22
Defining Exception Classes, cont.
  • class DivideByZeroException

23
Defining Exception Classes, cont.
24
Defining Exception Classes, cont.
25
Defining Exception Classes, cont.
26
Java 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.

27
Preserve 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

28
Preserve getMessage, cont.
  • Also include a default constructor.
  • public MyException()
  • super(MyException thrown)
  • More_Code_If_Appropriate

29
Programming 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.

30
Guidelines
  • 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.

31
Guidelines, 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.

32
Using 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

33
Declaring 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

34
Declaring 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

35
Accounting 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.

36
Accounting 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
  • class DoDivision

38
Accounting for Exceptions, cont.
  • A throws clause can include more than one
    exception type.
  • example
  • public int someMethod()throws
  • IOException, DivideByZeroException

39
Accounting 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.

40
Exceptions 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.

41
Exceptions 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.

42
Exceptions 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.

43
throws 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.

44
The 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.

45
Multiple 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.

46
Multiple Throws and Catches, cont.
47
Multiple Throws and Catches, cont.
48
Multiple Throws and Catches, cont.
49
Multiple Throws and Catches, cont.
50
Multiple Throws and Catches, cont.
  • class NegativeNumbersException

51
Java 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.

52
Programming 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.

53
Keep 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.

54
Keep It Simple, cont.
  • public void methodB()
  • ...
  • try
  • ...
  • methodA()
  • ...
  • catch (MyException e)
  • ...

55
Nested 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.

56
Nested 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.

57
The 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

58
The finally Block, cont.
  • syntax
  • try
  • catch Block(s)
  • finally
Write a Comment
User Comments (0)
About PowerShow.com