Handling errors Exception handling and throwing Simple file processing

Handling errors

Exception handling and throwing

Simple file processing

Outline

• Error example• Defensive Programming

• Throwing Exception

• Catching Exception

• Defining new Exception Types– Checked vs unchecked

Error situations

• Programmer errors– Incorrect implementation– Inappropriate object request

• Errors often arise from the environment:– incorrect URL entered– network interruption

• File processing is particularly error prone:– missing files– lack of appropriate permissions

Example: Runtime error

• Use:AddressBook friends = new AddressBook(); friends.removeDetails("frederik");

• Result:java.lang.NullPointerException

at AddressBook.removeDetails(AddressBook.java:119) ...

• In class AddressBook:public void removeDetails(String key) { ContactDetails details = (ContactDetails) book.get(key); book.remove(details.getName()); ...}

1. returns null when key

does not exist in book2. trying to call method on null

results in exception

Outline

• Error example

• Defensive Programming• Throwing Exception

• Catching Exception

• Defining new Exception Types– Checked vs unchecked

Defensive programming

• Defensive programming in client-server interaction– server assumes that clients are not well

behaved (and potentially hostile)– E.g. server checks arguments to constructors

and methods

• Significant overhead in implementation

Defensive programming

• Modified method in class AddressBook:

public void removeDetails(String key) {

if(keyInUse(key)) {

ContactDetails details =

(ContactDetails) book.get(key);

book.remove(details.getName());

book.remove(details.getPhone());

numberOfEntries--;

}

}

check argument

Server error reporting

• How to report illegal arguments?– To the user?

• is there a human user• can they solve the problem?

– To the client object• return a diagnostic value• throw an exception

Returning a diagnostic

public boolean removeDetails(String key) { if(keyInUse(key)) { ContactDetails details = (ContactDetails) book.get(key); book.remove(details.getName()); book.remove(details.getPhone()); numberOfEntries--; return true; } else { return false; }}

did any errors arise?

QUIZWhich of the three

remove methods use appropriate defensive programming?

1. none

2. A

3. B

4. C

5. A, B

6. A, C

7. B, C

8. All three

private class Dictionary {

List<String> list = new ArrayList<String>();

public void add(String w) { list.add(w); }

public boolean removeA(String w) {

list.remove(list.indexOf(w));

return true;

}

public boolean removeB(String w) {

if (list.size()==0) return false;

else return removeA(w);

}

public boolean removeC(String w) {

if (!list.contains(w)) return false;

else return removeA(w);

}

}

Client responses

• Test the return value– Attempt recovery on error– avoid program failure

• Ignore the return value– cannot be prevented– likely to lead to program failure

• Exceptions are preferable

Outline

• Error example

• Defensive Programming

• Throwing Exception• Catching Exception

• Defining new Exception Types– Checked vs unchecked

Exception-throwing principles

• A special language feature

• No special return value needed

• Errors cannot be ignored in the client– The normal flow-of-control is interrupted

• Specific recovery actions are encouraged

Throwing an Exceptionpublic ContactDetails getDetails(String key) { if (key==null) { throw new IllegalArgumentException(

"null key in getDetails"); } return (ContactDetails) book.get(key);}

• An exception object is constructed:– new ExceptionType("...");

• The exception object is thrown:– throw ...

The effect of an exception

• The throwing method finishes prematurely

• No return value is returned

• Control does not return to the client's point of call– so the client cannot carry on regardless

• A client may 'catch' an exception

Outline

• Error example

• Defensive Programming

• Throwing Exception

• Catching Exception• Defining new Exception Types

– Checked vs unchecked

The try block

• Clients catching an exception must protect the call with a try block

try {

Protect one or more statements here.

} catch(Exception e) {

Report and recover from the exception here

}

The try block

try { addressbook.saveToFile(filename); tryAgain = false;} catch(IOException e) { System.out.println("Unable to save to " + filename); tryAgain = true;}

exception thrown from here

control transfers to here

Catching multiple exceptions

try { ... ref.process(); ...} catch(EOFException e) { // Take action on an end-of-file exception. ...} catch(FileNotFoundException e) { // Take action on a file-not-found exception. ...}

The finally clause

try { Protect one or more statements here.} catch(Exception e) { Report and recover from the exception here.} finally { Perform any actions here common to whether or not an exception is thrown.}

The finally clause

• A finally clause is executed even if a return statement is executed in the try or catch clauses

• An uncaught or propagated exception still exits via the finally clause

QUIZWhich statement is

executed immediately after the throw statement?

1. Line A

2. Line B

3. Line C

4. Line D

5. Program stops with exception failure

6. None of 1-5

public static void main(String[] args) {

int arg = 0;

double inv = inverse(arg);

System.out.println(arg);

}

private static double inverse(int n) {

double result=0;

try {

if (n==0)

throw new IllegalArgumentException(

"cannot take inverse of 0");

result = 1.0/n;

} catch (IllegalArgumentException e) {

e.printStackTrace();

} finally {

return result;

}

}

A

B

C

D

Outline

• Error example

• Defensive Programming

• Throwing Exception

• Catching Exception

• Defining new Exception Types– Checked vs unchecked

Defining new exceptions

• Extend Exception or RuntimeException

• Define new types to give better diagnostic information– include reporting and/recovery information

The exception class hierarchy

Exception categories

• Checked exception– subclass of Exception– use for anticipated failures – where recovery may be possible

• Unchecked exception– subclass of RuntimeException– use for unanticipated failures– where recovery is unlikely

Unchecked exceptions

• Use of these is 'unchecked' by the compiler

• Cause program termination if not caught– this is normal practice– NullPointerException is a typical

example

Checked exceptions

• Checked exceptions are meant to be caught

• The compiler ensures that their use is tightly controlled– in both server and client

• Used properly, failures may be recoverable

The throws clause

• Methods throwing a checked exception must include a throws clause:

public void saveToFile(String destinationFile) throws IOException { ... }

Example: new checked exception

public class NoMatchingDetailsException extends Exception { private String key;  public NoMatchingDetailsException(String key) { this.key = key; }  public String getKey() { return key; } public String toString() { return "No details matching '" + key + "' were found."; }}

QUIZAny compiler errors ?

1. No compiler errors

2. Method A: needs ”throws” in header

3. Method A: needs ”try-catch” in body

4. Method B: needs ”throws” in header

5. Method main: needs ”throws” in header

6. Both 2 and 4

7. Both 4 and 5

8. Both 2, 4 and 5

9. Other errors

public class Quiz3 {

private static class MyException

extends Exception {}

private static void B() {

throw new MyException();

}

private static void A() {

B();

}

public static void main(String[] args) {

try {

A();

} catch (MyException e) {

e.printStackTrace();

}

}

}

QUIZWhat is the difference between checked and unchecked exceptions?

1. Unchecked exceptions may print any kind of message, whereas checked ones must print a programmer defined message

2. Unchecked exceptions must be handled with a programmed try/catch block, and checked exceptions with a try/catch/finally block

3. Unchecked exceptions need not be handled, but checked exceptions must be handled with a try/catch block

4. Checked exceptions must be handled with a programmed try/catch block, and unchecked exceptions with a try/catch/finally block

5. Checked exceptions need not be handled, but unchecked exceptions must be handled with a try/catch block

6. There is no formal difference between checked and unchecked exceptions

Outline

• Input/output• Text files

• Terminal / keyboard

• Binary Files

Input-output

• Input-output is particularly error-prone– it involves interaction with the external

environment

• java.io.IOException is a checked exception

Two ways to store data

• Text format– *.txt, *.java, *.xml– human-readable form– Sequence of characters

• integer 12345 stored as 49 50 51 52 53 (ascii for "1" "2" "3" "4" "5“)

– use Reader and Writer (and their subclasses)(based on char type)

• Binary format– *.doc, *.class, *.pdf– more compact and efficient

• integer 12345 stored as 00 00 48 57 (12345 = 48*256+57)

– Use InputStream and OutputStream (and their subclasses)(based on byte type)

Outline

• Input/output

• Text files• Terminal / keyboard

• Binary Files

Text output

• Use the FileWriter class– open a file– write to the file– close the file

• Failure at any point results in an IOException.

Text outputtry { FileWriter writer = new FileWriter("name of file"); while(there is more text to write) { ... writer.write(next piece of text); ... } writer.close();} catch(IOException e) { something went wrong with accessing the file}

QUIZWhich statements need to go in a try block?

1. A and B

2. B and C

3. C and D

4. D and E

5. A, B and C

6. B, C and D

7. C, D and E

8. A, B, C and D

9. B, C, D and E

import java.io.*;

public class Quiz4 {

public static void main(String[] args) {

String line = null;

BufferedReader reader = null;

reader = new BufferedReader(

new FileReader("input.txt"));

line = reader.readLine();

reader.close();

}

}

ED

C

BA

Text input

• Use the FileReader class• Augment with Scanner for line-based inputtry { Scanner in = new Scanner( new FileReader("name of file")); while(in.hasNextLine()) { String line = in.nextLine(); do something with line } in.close();} catch(FileNotFoundException e) { the specified file could not be found}• IOExceptions from FileReader “swallowed” by Scanner

Outline

• Input/output

• Text files

• Terminal / keyboard• Binary Files

User input from terminal window

• Similar to reading from a text file– construct a Scanner from System.in– no closing needed

Scanner in = new Scanner(System.in); System.out.println("type a line of input:"); String input = in.nextLine(); do something with input

QUIZ

What is written if file ”input.txt” does not exist?

1."IOException"

2."FileNotFoundException"

3."IOException”+”FileNotFoundException"

4. Something else is written

5. Compiler error: cannot have 2 catches

6. Compiler error: wrong order of catches

7. Other compiler error

try {

String line = null;

BufferedReader reader = new BufferedReader(

new FileReader("input.txt"));

line = reader.readLine();

reader.close();

} catch (IOException e) {

System.out.print ("IOException");

} catch (FileNotFoundException e) {

System.out.print ("FileNotFoundException");

}

Outline

• Input/output

• Text files

• Terminal / keyboard

• Binary Files

Object streams

• ObjectOutputStream class can save entire objects to disk

• ObjectInputStream class can read objects back in from disk

• Objects are saved in binary format (and streams are used)

• similar to text files:– open, read/write, close

• Writing object to file:BankAccount b1 = ...;ObjectOutputStream out = new ObjectOutputStream(new

FileOutputStream("accounts.dat"));out.writeObject(b1);

• Reading object from file:ObjectInputStream in = new ObjectInputStream(new

FileInputStream("accounts.dat");BankAccount b2 = (BankAccount) in.readObject();

• Objects that are written to a file must be instances of a class implementing the Serializable interface:

public class BankAccount implements Serializable {...}

Serializable interface has no methods

readObject may throw a (checked) ClassNotFoundException

Use container and write a single object

• Objects of any size written/read in a single statement:

ArrayList a = new ArrayList();

... // add many objects to array list

out.writeObject(a)

• java.util.ArrayList implements Serializable

• Objects stored in the array list must also be instances of a class implementing Serializable