Lecture Today's SOFT1x02 05: Exceptions
School of Information Technologies Using Exceptions
Read Big Java: Ch 15, Ch 4.7, Ch 16.1
August 07
SOFT1x02 University of Sydney
2
Argh! Run-time Errors!* Exceptions
Your friend when thigngs go baddly rong^Q#((Q#%_)U*((__))..
Whenever a Java program deals with the external environment, many things can go wrong
un-available blah not allowed to blurgh wrong format of bleagh etc.
How will the program cope?
have many different return values, indicating error conditions; then have calling program test for each? there must be a cleaner way to arrange it!
SOFT1x02 University of Sydney
*segmentation fault. core dumped. day ruined.
August 07
5
Exceptions
Exceptions are a mechanism to gracefully handle run-time errors. In general, you try a piece of code and catch any exceptions generated.
Using Exceptions
Exception mechanism: When an error is encountered
Construct an exception Object (which contains information about the error); Throw (also called "raise") the exception;
This stops normal flow of control.
The exception may be caught somewhere and dealt with; otherwise the execution stops.
August 07
SOFT1x02 University of Sydney
6
August 07
SOFT1x02 University of Sydney
7
1
How to throw an exception
... if (aWeight < 0.0) { // expecting non-negative throw new IllegalArgumentException("negative weight for "+this.mName); /*this location can never be reached */ } /* code here for the normal case */
When to throw an exception?
You might throw an exception when:
an error or a situation occurs that makes the normal flow of processing unsuitable; `someone else' should handle the error. Exceptions are especially useful if the same type of error occurs in several locations in a program.
When code catches an exception,
the error can be dealt with, and execution may continue, or it can clean up the damage and exit.
August 07
SOFT1x02 University of Sydney
8
August 07
SOFT1x02 University of Sydney
9
What exception?
There are a variety of Exception subclasses already in the library. You can also declare your own subclass
class AnimalNotHungryException extends Exception { public AnimalNotHungryException(String detail) { super(detail); } } It is good practice to declare a constructor taking a message
August 07 SOFT1x02 University of Sydney
Exception handling in Java
Separate the normal case code ("try") from the code for weird situations ("catch") Have several different catch clauses, depending on kind of exception The optional finally block is always executed at the end of the catch region.
After try clause completes successfully, or after a catch block is executed.
try { // do something // which could throw // Exceptions } catch(EOFException e) { // do something to deal with // the situation } catch(FileNotFoundException e) { // do something else } catch (Exception e) { // do something very general } finally { // code that should happen // after normal/weird case }
10
August 07
SOFT1x02 University of Sydney
11
Exception catching Example
try { double r1 = quadraticRoots(a, b, c); } catch(ArithmeticException e) { System.out.println("Oops: " + e.toString()) }
PSST! Pass it on...
If an exception occurs in a method
constructed and thrown explicitly or raised by some other method that is called,
Possible output:
You can refer to e in the catch clause
> Oops: quadratic equation has no real roots
And if it cannot be handled within the method (i.e., if there is no catch block for it associated with a try block containing the place where the exception occurred), Then that method will terminate and throw the same exception to the caller of the method. The exception will be passed up until someone can handle it.
12
August 07 SOFT1x02 University of Sydney
August 07
SOFT1x02 University of Sydney
13
2
Declaring Exceptions
Methods should declare the exceptions they can throw:
public void read() throws IOException { read data from a file }
Checked or Unchecked?
Java has these two types of exceptions:
All exceptions that are derived from RuntimeException are unchecked; all other subclasses of Exception are checked.
This is enforced for a checked exception
So caller can know what exceptions might arise, and be prepared to catch them (or throw them further).
Java has checked and unchecked exceptions.
August 07 SOFT1x02 University of Sydney
Checked exceptions are checked by the compiler to ensure they are handled within the method or thrown further; Unchecked exceptions do not need to be declared: the compiler won't check that they are handled or passed on properly.
14
August 07 SOFT1x02 University of Sydney
15
Checked Exceptions
Checked exceptions
force tighter coding
so they can make coding painful (unless you use an IDE that puts try/catch automatically!);
"Throws" header
public void getData(...) throws IOException { read data from a file }
are useful especially for situations out of programmer's influence (e.g., in groups!)
Unchecked exceptions are often produced by programmer errors in ordinary code, e.g.,
NullPointerException IndexOutOfBoundsException ClassCastException
SOFT1x02 University of Sydney
public void dealWithData(...) { try { /*call getData()*/ } catch (IOException e) { System.out.println("Oops: faulty datafile?"); } }
August 07
16
August 07
SOFT1x02 University of Sydney
17
Exceptions principles
Do not throw an exception
To avoid thinking about flow control in expected situations
e.g., don't deal with the end of the input this way!
Heirarchy of Exceptions
Here are some of the common exceptions you may use
to "simplify" your code!
Do not catch an exception
if it is not the right place to handle it maybe let the calling routine handle it; to shut the compiler up!
Use exceptions in exceptional cases.
August 07 SOFT1x02 University of Sydney August 07 SOFT1x02 University of Sydney
18
19
3
Exceptions: Summary
try {...}
compulsory
catch {...}
at least one
finally {...}
optional
Java has checked and unchecked exceptions.
Checked exceptions which are not caught internally must be mentioned in method header throws clause.
RuntimeException and all its subtypes are unchecked All the others are checked
August 07 SOFT1x02 University of Sydney
Exceptions are not suitable for expected situations flow-control! Catch and handle the exception you if can do so sensibly, else pass it on.
20
August 07 SOFT1x02 University of Sydney
21
Common errors
Putting try/catch blocks with too small scope:
put them around the entire piece of code you expect to work!
File Input and Exceptions
When files are read they are expected in a certain format:
name: Bill Bloggs; age 24 name Bill Bloggs age 24 Name Bloggs, Bill Age: 24
Returning too general an Exception type:
use the appropriate exception if you can
Not conveying information with the exception thrown:
construct it with a detailed message.
August 07
SOFT1x02 University of Sydney
22
August 07
SOFT1x02 University of Sydney
23
Parsing
Files have to be parsed:
if they are not in the right format then they won't be understood.
File reading
When reading a file
try
to read in the data in the right form;
When reading a file, incorrect formatting often uses Exceptions.
e.g., NumberFormatException, IllegalArgumentException, etc. (all Runtime exceptions)
catch
the case(s) where it isn't;
throw
an exception with detailed information about what caused the error.
August 07
SOFT1x02 University of Sydney
24
August 07
SOFT1x02 University of Sydney
25
4
Non-Persistence
Data used by a Java program has different lifetimes
next, Persistence
instance variables: from object construction till the object is garbage collected (when there are no more references to it) local variables: from method entry till method return
But all data is lost when the program ends
including if the program crashes. Data is "transient".
Operating system design reflects hardware:
typical RAM technology does not keep its state when power is turned off. (You have to boot-up your machine.)
August 07
SOFT1x02 University of Sydney
27
Persistence
The data kept by organizations is This data must not be lost when programs end or computers crash! It is stored on devices that keep their state until overwritten
disk tape CD DVD etc. essential, valuable.
File System
A key aspect of the operating system is to provide a file system. Divide the persistent storage into variable size chunks
user-assigned names hierarchical naming, through folders/directories access control text files are easily read and written to; binary files need more tricks (translation). We will focus on text files.
Files can be text or binary.
August 07
SOFT1x02 University of Sydney
28
August 07
SOFT1x02 University of Sydney
29
File access from Java
Construct an object instance in your program that represents the access.
There are several possible classes, depending on how you will access it! e.g., FileWriter f = new FileWriter(filename); Warning: this constructor throws FileNotFoundException
Writing text files
Use the PrintWriter class and its methods print and println:
// open file for writing: FileWriter writer = new FileWriter( filename ); // use write() to write one character at a time or.. PrintWriter out = new PrintWriter( writer ); // an alternative shortcut is // PrintWriter out = new PrintWriter(filename); out.println( "Hello World" ); // always close the file after you are done // to commit changes out.close();
Call methods of this object.
The Java environment deals with the OS to operate on the file. Remember to call f.close() once you no longer need to access the file.
SOFT1x02 University of Sydney
August 07
30
August 07
SOFT1x02 University of Sydney
31
5
Reading from Text files
The FileReader class has a method (inherited from Reader interface) int read() to read one character from the file This is too painful to use for most purposes So construct a Scanner that takes its information from the Reader Scanner has a method nextLine() to read a whole line (as a String)
Scanner in = new Scanner(f); String line = in.nextLine();
Reading Primitive types
When a line of a file contains "...