JAVA EXCEPTION HANDLING
N.V.Raja Sekhar Reddy
www.technolamp.co.in
Want more interesting...
Watch and Like us @ https://www.facebook.com/Technolamp.co.in
subscribe videos @ http://www.youtube.com/user/nvrajasekhar
2. Throwing Exceptions
What is a good program? A program that is
reliable?
Not just giving correct answer on correct input
Should protect against possible errors (invalid
password, not a picture file, etc)
3. Good programs
Need a robust program, reliable in the eyes of a
novice user
It should not (“cannot”) crash easily - what if
Word always crashed when you hit the control
key?
4. Good Programs
How do we ensure a robust program?
Option 1 – return a special value to determine if
the method succeeded or failed
Ex. Make withdraw return true or false
What’s wrong with this?
Calling method may not check answer
Calling method may not know what to do
5. Good Programs
Option 2 - Use exceptions
Exception – an error condition that can occur
during the normal course of a program
execution
Exception handling is another form of control
structure (like ifs and switch statements)
When an error is encountered, the normal flow of
the program is stopped and the exception is handled
6. Exceptions
We say an exception is thrown when it occurs
When the exception-handling code is executed,
the error is caught
Examples:
Dividing by zero
Accessing a null object
7. Exceptions
What happens when exceptions occur?
An Exception object is thrown
What happens when an Exception is thrown?
normal execution stops and exception handling begins
What does the Exception object know?
the name of the problem
the location where it occurred
and more…
8. Exceptions
Why use exceptions?
consistency (everyone else does it)
Java API classes use exceptions.
Other programming languages do too!
flexibility
programmer can decide how to fix problems.
simplicity
Easy to pinpoint problems.
9. Handling Exceptions
Do nothing
program crashes if the exception occurs!
Propagate (throw) it
tell the method’s caller about it and let them decide what
to do
Resolve (try-catch) it in our method
fix it or tell the user about it and let them decide what to
do
10. Handling Exceptions
So far, we have let the system handle exceptions
int score = in.nextInt();
If the user enters “abc123”
Exception in thread "main"
java.util.InputMismatchException
at java.util.Scanner.throwFor(Scanner.java:819)
at java.util.Scanner.next(Scanner.java:1431)
at java.util.Scanner.nextInt(Scanner.java:2040)
at java.util.Scanner.nextInt(Scanner.java:2000)
at Test.main(Test.java:5)
11. Handling Exceptions
Says in English:
System has caught an error described as a
InputMismatchException
Thrown because a String cannot be converted to an
integer
When system handles, we often get a program crash
Instead of the system, we can handle to improve
robustness
12. Handling Exceptions
Better solution: Instead of letting the program
crash, use Exception Handling to improve
program’s robustness
Exceptions cannot be ignored
Exceptions are handled by Exception Handlers
directly
13. Throwing Exceptions
If there is an error in the value of a parameter,
we can throw exceptions to make the user
accountable
1. Decide what type of exception to throw
2. Test for condition, and throw the exception if
condition is violated
14. Example
Throw an exception object to signal an
exceptional condition
Example: What do we do if the amount to
withdraw is greater than the balance?
IllegalArgumentException: illegal parameter value
15. Problem
public class BankAccount
{
public void withdraw(double amount)
{
if (amount > balance)
{
?????????
}
balance = balance - amount;
}
. . .
}
16. Solution #1
public class BankAccount
{
public void withdraw(double amount)
{
if (amount > balance)
{
IllegalArgumentException exception
= new IllegalArgumentException("Amount
exceeds balance");
throw exception;
}
balance = balance - amount;
}
. . .
}
17. Solution #2
public class BankAccount
{
public void withdraw(double amount)
{
if (amount > balance)
{
throw new IllegalArgumentException("Amount
exceeds balance");
}
balance = balance - amount;
}
. . .
}
19. Checked/Unchecked Exceptions
Checked Exception – checked at compile time
Complier ensures that you are handling a possible
problem
These errors are due to external circumstances that
the programmer cannot prevent
Majority occur when dealing with input and output
For example, IOException
20. Checked/Unchecked Exceptions
Unchecked Exception = Runtime Exceptions
Extend the class RuntimeException or Error
They are the programmer's fault
Examples of runtime exceptions:
NumberFormatException
IllegalArgumentException
NullPointerException
Optional to deal with these
Example of error: OutOfMemoryError
Can’t do anything about these catastrophic
problems, so don’t deal with it
21.
22. Checked/Unchecked Exceptions
Unchecked Exceptions result from deficiencies
in your code, so should check on own
Null object reference
Sending a negative value to Math.sqrt()
Checked Exceptions are not the fault of the
coder
Problems with the file format, user input, etc.
23. Checked/Unchecked Exceptions
Categories aren't perfect:
Scanner.nextInt throws unchecked
InputMismatchException
Programmer cannot prevent users from entering
incorrect input
This choice makes the class easy to use for beginning
programmers
24. Checked/Unchecked Exceptions
Deal with checked exceptions principally when
programming with files and streams
For example, use a Scanner to read a file
String filename = . . .;
FileReader reader = new FileReader(filename);
Scanner in = new Scanner(reader);
But, FileReader constructor can throw a
FileNotFoundException
25. Handling Checked Exceptions
1. Handle the exception
2. Tell compiler that you want method to be
terminated when the exception occurs
Use throws specifier so method can throw a
checked exception
public void read(String filename) throws
FileNotFoundException
{
FileReader reader = new
FileReader(filename);
Scanner in = new Scanner(reader);
. . .
}
26. Handling Checked Exceptions
throws tells the compiler to “pass the buck” to the
method that called this method
Can propagate multiple exceptions:
public void read(String filename) throws IOException,
ClassNotFoundException
Can also group using hierarchy
If method can throw an IOException and
FileNotFoundException, only use IOException
27. Handling Checked Exceptions
Why propagate when we could handle the error
ourselves?
We may not know how to
Let user of my code decide
Better to declare exception than to handle it
incompetently
28. Catching Exceptions
At some point, an exception should be dealt
with
If not, program terminates with error message
Professional code requires more sophistication –
cannot just allow errors to kill program
What would happen if all of my.wisc.edu turned off
if you entered wrong password?
29. Catching Exceptions
To deal with this problem, install exception
handlers in your code to deal with possible
exceptions
Handlers are try/catch statements
30. Try-Catch
Put statement(s) that could cause an error in the
try block
Error handling code goes in catch block
Only is executed if there was an error
Can have multiple catch blocks, one for each
possible type of exception
32. try
{
String filename = . . .;
FileReader reader = new FileReader(filename);
Scanner in = new Scanner(reader);
String input = in.next();
int value = Integer.parseInt(input);
. . .
}
catch (IOException exception)
{
exception.printStackTrace();
}
catch (NumberFormatException exception)
{
System.out.println("Input was not a number");
}
33. Example
3 types of error can be thrown
FileNotFoundException is thrown by
FileReader constructor caught by
IOException clause
NoSuchElementException is thrown by
Scanner.next not caught, thrown to caller
NumberFormatException is thrown by
Integer.parseInt() caught by second clause
34. Catching Exceptions
If there are no errors, the catch block is skipped
If an exception is thrown, the try block stops
executing immediately and jumps to the catch
block
36. Exception Information
Why do we have Exception objects?
We can get information on where the error happened
and what exactly happened
Exception objects have 2 methods defined:
getMessage() (what happened?)
printStackTrace() (where did it happen?)
37. getMessage
Returns the data that cause the error
Example:
…
}catch(NumberFormatException e){
System.out.println(e.getMessage());
}
38. printStackTrace
Prints out a trace of methods that caused the
error starting at the root of the error
Where did the exception occur? What method called
this code to execute..etc.
This is what the system does when an exception is
thrown
Example:
…
}catch(NumberFormatException e){
e.printStackTrace();
}
39. Catching ALL Exceptions
public double average( String data )
{
try
{
int sum = 0;
for ( int i=0; i < data.length(); i++ )
sum += Integer.parseInt(data.charAt(i));
return sum/data.length();
}
catch ( Exception e ) // catch ALL exceptions
{
System.out.println( e );
return 0;
}
}
40. Catching ALL Exceptions
Why is this probably a bad idea?
Probably want to handle each type of exception
differently
Don't want to catch things like
NullPointerExeption
41. Catching Exceptions
IMPORTANT! Order of catch blocks matters
} catch (Exception e){
System.out.println(e.getMessage());
} catch (NumberFormatException e){
System.out.println("'" + str + "'not valid
input, Please use digits only");
}
You should go specific to generic
NumberFormatException is a specific type of the class
Exception (inheritance)
43. String filename=args[0], input;
try {
scanner = new Scanner(new File(filename));
input = scanner.nextLine();
int value = Integer.parseInt( input );
double reciprocal = 1.0 / value;
System.out.println( "rec=" + rec );
}
catch ( NumberFormatException e ) {
S.o.pln( input + " is not an integer");
}
catch ( ArithmeticException e ) {
S.o.pln( "Can't divide by zero" );
}
catch ( FileNotFoundException e ) {
S.o.pln( filename + " Not Found" );
}
finally { S.o.pln( "Done" ); }
44. Catching Exceptions
What if an exception is thrown and there is no
catch block to match?
The system handles it (terminates program and
prints the stack trace)
45. The finally clause
Recall that whenever an exception occurs, we
immediately go to the catch block
What if there is some code we want to execute
regardless of whether there was an exception?
finally block is used
46. The finally clause
try{
distance = Double.parseDouble(str);
if (distance < 0){
throw new Exception("Negative distance is not
valid");
}
return distance;
} catch (NumberFormatException e){
System.out.println("'" + str + "'not valid
input, Please use digits only");
} catch (Exception e){
System.out.println(e.getMessage());
} finally {
System.out.println(“Done”);
}
47. The finally clause
finally is executed NO MATTER WHAT
Even if there is a break or return in the try block
Good for “cleanup” of a method
52. try-catch Control Flow
code before try
exception occurs
try block catch block
no exceptions occur
code after try
53. try-catch Control Flow
code before try
try block
no exceptions
occurred
finally block (if it exists)
code after try
54. try-catch Control Flow
code before try
exception occurs
try block catch block
finally block (if it exists)
code after try
55. try-catch Control Flow
exception occurs
code before try
true matches first
try block catch block?
no exceptions
occurred 1st catch block false
true matches next
2nd catch block catch block?
false
finally block (if it exists)
code after try
56. Propagating Exceptions
When a method may throw an exception, either
directly or indirectly, we call the method an
exception thrower.
Every exception thrower must be one of two
types:
a catcher, or
a propagator.
57. Propagating Exceptions
An exception catcher is an exception thrower that
includes a matching catch block for the thrown
exception.
An exception propagator does not contain a
matching catch block.
A method may be a catcher of one exception
and a propagator of another.
58. Example
The following figure shows a sequence of method calls
among the exception throwers.
Method D throws an instance of Exception. The green
arrows indicate the direction of calls. The red arrows
show the reversing of call sequence, looking for a
matching catcher. Method B is the catcher.
The call sequence is traced by using a stack.
60. Propagating Exceptions
If a method is an exception propagator, we need to
modify its header to declare the type of exceptions the
method propagates.
We use the reserved word throws for this declaration.
public void C( ) throws Exception {
...
}
public void D( ) throws Exception {
...
}
61. Propagating Exceptions
Without the required throws Exception clause,
the program will not compile.
However, for exceptions of the type called
runtime exceptions, the throws clause is optional.
62. Propagating vs. Catching
Do not catch an exception that is thrown as a
result of violating a condition set by the client
programmer.
Instead, propagate the exception back to the
client programmer’s code and let him or her
handle it.
63. Exceptions in a Constructor
We can thrown an exception in the constructor
if a condition is violated
For example, we may throw an
IllegalArgumentException if a parameter value
is invalid
Hinweis der Redaktion
What exceptions can occur in this code fragment? NullPointerException ArithmeticException: / By Zero
What exceptions can occur in this code fragment? IOException NumberFormatException ArithmeticException – DivideByZero NegativeArraySizeException
What exceptions can occur in this code fragment? IOException NumberFormatException ArithmeticException – DivideByZero NegativeArraySizeException
Create Exception Hierarchy Handout (online and hardcopy for class) Link to this for "Java Exceptions" web page.
catch block must match the class of exception that occurs