Exception Handling Chapter 12

wakecabbagepatchSoftware and s/w Development

Nov 18, 2013 (3 years and 8 months ago)

71 views

Exception Handling

Chapter 12


Errors
-

the various bugs, blunders, typos and
other problems that stop a program from
running successfully


Natural part of the software development process



There are two kinds of problems that you may
encounter in Java


Exceptions


events that signal an unusual
circumstance has taken place as a program runs


Errors


events that signal the interpreter is
having problems that may be unrelated to your
program




Consider the following code:

import
java.util.Scanner
;


public class
EnterNumber

{


public static void main(String[ ]
args
) {



Scanner input = new Scanner(
System.in
);



System.out.print
("Enter a whole number between 0 and 9: ");



int

guess =
input.nextInt
();




System.out.println
(" Your guess is " +guess);



}

}




This program has a few flaws.


What happens when any integer is entered?


What happens when a decimal value is entered?



When an integer outside the desired range is
entered, the program continues with the
invalid value


When a decimal is entered, the program
comes crashing to the ground



The key to fixing a program bug is examining
the message that appears when the program
crashed


Exception in thread "main"
java.util.InputMismatchException




The Java programming language has a
mechanism called
exception handling


With exception handling, a program can detect
that things are about to go wrong and respond
by creating a brand new object


That object is from the Exception class


When handled properly, we can catch the
exception, execute some recovery code and
move on to the next statement


Throwable

Exception

Error

ClassNotFoundException

IOException

RunTimeException

Many others

LinkageError

VirtualMachineError

Many others

ArithmeticException

NullPointerException

IndexOutOfBounds

Exception

IllegalArgument

Exception

Many others


System errors

are thrown by JVM and
represented in the
Error

class.


The
Error

class describes internal system errors.


Such errors rarely occur.


If one does, there is little you can do beyond notifying
the user and trying to terminate the program gracefully.


Error

LinkageError

VirtualMachineError

Many others


Exception
describes errors caused by your
program and external circumstances.


These errors can be caught and handled by your
program.


Exception

ClassNotFoundException

IOException

RunTimeException

Many others

ArithmeticException

NullPointerException

IndexOutOfBounds

Exception

IllegalArgument

Exception

RuntimeException
,
Error

and their subclasses
are known as
unchecked

exceptions
.

All
other exceptions are known as
checked
exceptions
, meaning that the compiler forces the
programmer to check and deal with the
exceptions.



Unchecked exceptions reflect programming
logic errors that are not recoverable


NullPointerException

is thrown if you
access an object through a reference
variable before an object is assigned to it


IndexOutOfBoundsException

is thrown if
you access an element in an array outside
the bounds of the array


These are the logic errors that should be
corrected in the program.


To catch the problem before the program
crashes, Java provides some assistance:


throw



creates a new exception object


throws



passes the exception from a method
to the code


try



encloses code that has a potential
exception


catch



deals with the exception, buries it, and
then moves on



To catch the problem before the program
crashes, Java provides some assistance:


throw



creates a new exception object


throws



passes the exception from a method
to the code


try



encloses code that has a potential
exception


catch



deals with the exception, buries it, and
then moves on



try

block


Segment of code in which something might go
wrong


Attempts to execute


Acknowledging exception might occur


try

block includes:


Keyword
try


Opening and closing curly brace


Executable statements


Which might cause exception


catch

block


Segment of code


Immediately follows
try

block


Handles exception thrown by
try

block preceding
it


Can “catch”


Object of type
Exception


Or
Exception

child class


throw

statement


Sends
Exception

out of method


Can be handled elsewhere


catch

block includes:


Keyword
catch


Opening and closing parentheses


Exception

type


Name for
Exception

object


Opening and closing curly braces


Statements to handle error condition





finally

block


Use for actions you must perform at end of
try...catch

sequence


Use
finally

block to perform cleanup tasks


Executes regardless of whether preceding
try

block identifies an
Exception


Let’s catch our decimal exception:

import
java.util.Scanner
;


public class
EnterNumber

{


public static void main(String[ ]
args
) {



Scanner input = new Scanner(
System.in
);



System.out.print
("Enter a whole number between 0 and 9: ");




try {




int

guess =
input.nextInt
();




System.out.println
(" Your guess is " +guess);



} catch (Exception e) {




System.out.println
("Not a valid guess");





}


}

}



We can now
catch the
InputMismatch


With the try statement, the program now
terminates gracefully instead of crashing


The trick is to enclose the scanner input
statement inside a try clause


Now the computer watches for exceptions


If an exception is thrown, the computer jumps
straight to the catch clause



getMessage
( )


Since an exception is an object, the
getMessage

method may provide additional
information about the exception




try {




int

guess =
input.nextInt
();




System.out.println
(" Your guess is " +guess);



} catch (Exception e) {




System.out.println
("Not a valid guess");




System.out.println
("Message: " +
e.getMessage
( ));




}





printStackTrace
( )


Use this method if you want to see the
actual trace of the exception


Similar to the crash message




try {




int

guess =
input.nextInt
();




System.out.println
(" Your guess is " +guess);



} catch (Exception e) {




System.out.println
("Not a valid guess");




System.out.println
("Message: " +
e.getMessage
( ));




e.printStackTrace
( );




}





We caught a general Exception, but we can
also catch specific exceptions which may need
to be handled separately


We can also have multiple catch statements with
the try statement





try {




int

guess =
input.nextInt
();




System.out.println
(" Your guess is " +guess);



} catch (
java.util.InputMismatchException

e) {




System.out.println
("Not a valid guess");





}





Most ordinary exceptions that might be thrown
within a method must be accounted for in one of
two ways:

1.
The code that can throw an exception is placed within
a
try

block, and the possible exception is caught in a
catch

block within the same method

2.
The possible exception can be declared at the start of
the method definition by placing the exception class
name in a
throws

clause


Our code still has an issue with a valid
integer input where our input value may be
outside our desired range


(number between 0 and 9)


Let us use the
IllegalArgumentException

to
handle our range issue


We define the throw as part of the main


import
java.util.Scanner
;


public class
EnterNumber

{


public static void main(String[ ]
args
) throws
IllegalArgumentException
{






Scanner input = new Scanner(
System.in
);



System.out.print
("Enter a whole number between 0 and 9: ");





try {




int

guess =
input.nextInt
();




if (guess < 0 || guess > 9)





throw new
IllegalArgumentException
();




}




catch (
java.util.InputMismatchException

e) {




System.out.println
("Not a valid guess");




}




catch (
IllegalArgumentException

e) {




System.out.println
("Not between 0 and 9");




}



}

}


Before object
-
oriented programming
languages


Errors handled with confusing, error
-
prone
methods


When any method fails


Program sets appropriate error code


Difficult to follow


Application’s purpose and intended outcome lost in
maze of
if

statements


Coding mistakes because of complicated nesting


Java’s object
-
oriented, error
-
handling
technique


Statements of program that do “real” work


Placed together where logic is easy to follow


Unusual, exceptional events


Grouped


Moved out of the way


Advantage to object
-
oriented exception
handling


Flexibility in handling of error situations



Let’s write our code to prompt the user to
guess again if an invalid input occurs



We will use a while loop for the multiple
inputs as needed


Need to accept the input, then check for
accuracy


We can input as a string


Then parse as an integer

import
java.util.Scanner
;


public class
EnterNumber

{


public static void main(String[ ]
args
)



throws
IllegalArgumentException
{






int

guess = 0;



boolean

validGuess

= false;



Scanner input = new Scanner(
System.in
);






while (!
validGuess
){




System.out.print
("Enter a whole number between 0 and 9: ");




String
guessInput

=
input.next
();


// continued on next slide












try {





guess =
Integer.parseInt
(
guessInput
);





if (guess < 0 || guess > 9)






throw new
IllegalArgumentException
();





else






validGuess

= true;




}




catch (
NumberFormatException

e) {





System.out.println
("Not a valid integer");






System.out.println
("Try again");




}




catch (
IllegalArgumentException

e) {





System.out.println
("Not between 0 and 9");





System.out.println
("Try again");






}



}



System.out.println
("Your guess is " + guess);


}

}