FIT1002 2006

1

FIT1002FIT1002Computer ProgrammingComputer Programming

Unit 19Unit 19

File I/O and ExceptionsFile I/O and Exceptions

FIT1002 2006

2

ObjectivesObjectivesBy the end of this lecture, students should:

• understand simple character-oriented file input and output

• understand exceptions as mechanism of handlingabnormal circumstances

• understand the differences between throwing exceptions and aborting a program

• understand the difference between Exceptions and Errors

• be able to write code for character-oriented input and output using the Sanner class

• be able to write code using basic exceptions without subclassing

• use try & catch statements

Reading: Savitch, Sec. 10.1 (p. 574-596, p 606-607): File I/O

Savitch, Sec. 9.1: Exception Basics

FIT1002 2006

3

InputInput

We have used the Scanner class for character input from the console before…

•you must “import java.util.Scanner;”

•You must create a new scanner object :

Scanner console = new Scanner(System.in);

•new values can then be read from the Scanner object using

–console.nextInt() “for Integers”–console.nextFloat() “for Floats”–console.nextLine() “for Strings”–console.next() “any token”–etc (see Java API doc at Sun’s web site)

FIT1002 2006

4

Reminder: Using the Scanner Reminder: Using the Scanner ClassClass

Recall the method readLines in the class Message (Tutorial 8) to read in and concatenate a number of input lines:

import java.util.Scanner;

public abstract class Message { private String msg;… public void readLines() { Scanner console = new Scanner(System.in); String input = ""; while (!input.equals("STOP")) { msg += input; input = console.nextLine(); } }}

FIT1002 2006

5

System.inSystem.in

• You create a new scanner object for a particular input stream (“channel”):

Scanner console = new Scanner(System.in);

• this is obviously a constructor use, System.in is the parameter.

• System is a pre-defined class• System.in is a static (class) variable of System• It is a “stream”:

– a stream is something that you can read from or write to.

• Note that we also have System.out which is the standard output stream.

FIT1002 2006

6

Input/Output DevicesInput/Output Devices

Program

System.inSystem.out

FIT1002 2006

7

Using other Input SourcesUsing other Input Sources

• If you want to read from another source, you need to give another stream to the Scanner when it is constructed

• Example: reading from a file

• You need to construct a Scanner that is attached to the file

• check the Scanner constructors in the Java API

• So we can generate a Scanner for a particular file using the first constructor

… but we need to make that File available first

FIT1002 2006

8

FilesFiles

• to make the file available we need to “open” it.• “Opening a file” means

1. to construct a new File object in the program and 2. to attach it to a file in the Operating System.

• This can be done in a single step using an appropriate constructor for a File object (check the API).

• After constructing the File object, we need to construct a Scanner object for this file.

we will later see how we can easily let the user choose a file in an interactive program by using the type of file chooser dialog that you usually see in your operating system (Lectures on GUIs).

FIT1002 2006

9

Putting it all together…Putting it all together…

import java.io.*;import java.util.Scanner;

public class FileInputTest {private String message;

public String readLinesFromFile(String filename)

throws FileNotFoundException { File inFile = new File(filename); Scanner inScan = new Scanner(inFile);

String tmp=""; while (inScan.hasNext()) tmp += inScan.next()+” “; message = tmp; return tmp; } }

as before, this code read input lines into message, but now it does so from a file.

FIT1002 2006

10

NotesNotes

import java.io.*;import java.util.Scanner;

public class FileInputTest {private String message;

public String readLinesFromFile(String filename) throws FileNotFoundException { File inFile = new File(filename); Scanner inScan = new Scanner(inFile);

String tmp=""; while (inScan.hasNext()) tmp += inScan.next(); message = tmp; return tmp; } }

1. you need to import java.io.* to use files2. you need to import java.util.Scanner to use Scanners3. you can use “hasNext()” to test whether there is more input available4. you need to add “throws FileNotFoundException” to the method header

(more about this later).

FIT1002 2006

11

Checking End-of-FileChecking End-of-File

• how do you know that you have read the whole file without being forced to use a special token (like “STOP”) as the last word of the file?

• The Scanner knows whether there is still something to read…

public boolean console.hasNext()

• returns true if there are more tokens in the input and false otherwise.

• There are also specific checks whether the next token (if any) is of a particular type:

• hasNextInt()• hasNextFloat()• hasNextLine()• etc…

FIT1002 2006

12

File OutputFile Output

• We have already used simple output

System.out.println(“bla bla bla”);

Analyze this expression:• System (a class), • out (a static variable in the class System), • println(…) a message sent to System.out

• Recall: System.out is a printStream (Slide 5):

• The class PrintStream has a println(…) method

FIT1002 2006

13

PrintStream vs PrintWriterPrintStream vs PrintWriter

• To print to a file we have to replace the PrintStream System.out in the

System.out.println(“bla bla bla”);

• To do so we need to construct a new PrintStream and attach it to a file. However, looking up PrintStream in the API we find the following information:

“The PrintWriter class should be used in situations that require writing characters rather than bytes.”

FIT1002 2006

14

PrintWriterPrintWriter

• PrintWriter has print(…) and println(…)• We could open a file and attach it to a PrintWriter,

• more conveniently, a special constructor for PrintWriter allows us to do this automatically:

FIT1002 2006

15

Printing to a filePrinting to a fileimport java.io.*;import java.util.Scanner;

public class FileInputTest {private String message;

… public void writeLinesToFile(String filename)

throws FileNotFoundException { PrintWriter outWriter = new PrintWriter(filename);

outWriter.println("The text in this object is"); outWriter.println(message); outWriter.close(); } }

FIT1002 2006

16

Opening / Closing FilesOpening / Closing Files

1.Before you can use a file you need to “open” it.

2.When you are finished you need to “close” it.This signals to the O/S that you will not need

it anymore,it makes the file available to othersit also ensures that all characters from the

internal buffers are flushed to the file.

• Opening and closing of files can be performed implicitly by opening and closing the associated PrintWriter objects.

H e l l o !

System.out.println(“Hello!”);

FIT1002 2006

17

ExceptionsExceptions

• Exceptions are a special error handling mechanism.

• An exception can be “thrown” in a statement to abort the current method and signal to the calling code that something has gone wrong.

• In principle this is very similar to throwing an Error (as we have done in Constructors).

• The calling method can test whether an exception has occurred and react to this. This is done with a try-catch statement:• the “try” statement executes some code that may throw an exception

• If an exception happens, • the whole “try” block is immediately aborted and • the “catch” block is then executed

• If no exception happens, • the “try” block is completely executed• execution then skips the “catch” block and continues after it

FIT1002 2006

18

Handling Exceptions Handling Exceptions

• Many built-in methods signal problems by throwing exceptions• For example, the constructors associated with files throw a special kind

of exception, the FileNotFoundException.• We can use try-catch to handle this:

public class FileIOTest { private String message; public String readLinesFromFile(String filename) { try { File inFile = new File(filename); Scanner inScan = new Scanner(inFile); String tmp=""; while (inScan.hasNext()) tmp += inScan.next()+" "; message = tmp; return tmp; } catch (FileNotFoundException e) { System.out.println("Error: This File does not exist"); return ""; } }

FIT1002 2006

19

Throwing Exceptions Throwing Exceptions • You can also throw exceptions in your own code• This works just like throwing errors• You can handle your own exceptions in the same way as

built-in ones.public class ExceptionTest{ public void test(double aNumber) { try { System.out.println(mySqrt(aNumber)); } catch (Exception e) { System.out.println("Can't compute Sqrt of "+aNumber); } } public double mySqrt(double x) throws Exception {

if (x<0) throw new Exception(); else return Math.sqrt(x);

}}

FIT1002 2006

20

Throwing Exceptions: Notes Throwing Exceptions: Notes • the braces around the try and catch block are mandatory• you must declare that your method may throw an exception• you do not have to return anything when you throw an exception

(in fact, you can’t).

public class ExceptionTest{ public void test(double aNumber) { try { System.out.println(mySqrt(aNumber)); } catch (Exception e) { System.out.println("Can't compute Sqrt of "+aNumber); } } public double mySqrt(double x) throws Exception {

if (x<0) throw new Exception(); else return Math.sqrt(x);

}}

FIT1002 2006

21

The Exception Object The Exception Object

• An Exception is an object

• a catch clause declares – which type of exception it wants to catch (its class) and– a local variable to which this exception will be bound

• The Exception object contains useful (debugging) information, in particular an error message

– You can obtain this information using• the toString() method• the getMessage() method

– You can set the error message in the constructor

FIT1002 2006

22

Using Exception Objects Using Exception Objects

public class ExceptionTest{ public void test(double aNumber) { try { System.out.println(mySqrt(aNumber)); } catch (Exception e) { System.out.println(e.toString()); System.out.println(e.getMessage()); } }

public double mySqrt(double x) throws Exception { if (x<0) throw new Exception("Can't compute Sqrt of "+x); else return Math.sqrt(x); }}

FIT1002 2006

23

Exception in Call HierarchiesException in Call Hierarchies• You can also choose not to handle an exception (no try-catch)

• An exception that is not handled will “bubble up” the call hierarchy.

• Your code must declare in the method header that it is aware that an exception could occur using a “throws” declaration (see previous slide).

• Example: Method A calls Method B which in turn calls Method C

• Method C throws an exception • C is immediately aborted• if B does not handle the exception, B is also immediately aborted• A can now handle the exception or let it bubble up further

A B C

FIT1002 2006

24

Demo: Exceptions in Call Demo: Exceptions in Call HierarchiesHierarchies

public class TripleThrow { public void A(int x) { System.out.println("A running"); try { B(x); } catch (Exception e) { System.out.println("Caught exception while executing B"); } System.out.println("A finalizing"); } public void B(int x) throws Exception { System.out.println("B running"); C(x); System.out.println("B finalizing"); } public void C(int x) throws Exception { System.out.println("C running"); if (x<0) throw new Exception(); System.out.println("C finalizing"); }}

FIT1002 2006

25

Errors Errors • Previously (constructor lessons) we have thrown “Errors”

•The fundamental difference is • Exceptions must be handled

• either caught in a “try-catch”• or declared to bubble up with a “throws” declaration

• Errors can, but do not need to be handled• no “throws” declaration is required in the calling code

The advantage of Exceptions is that a programmer will automatically be made aware by the compiler that he/she has potentially forgotten to handle a particular exception. Thus Errors should only be used where it is a reasonable to let them bubble up to the top level (and thus abort the entire program). If you want the problem to be handled at some level in your code, you should use an Exception.

FIT1002 2006

26

Distinguishing Exceptions Types Distinguishing Exceptions Types (advanced, optional)(advanced, optional)

• We can handle exceptions selectively • handle only a specific exception type in a catch clause and

• let other exceptions “bubble up”

• Exceptions are in a class hierarchy, • The catch clause only handles exceptions of the type it has declared

• Exceptions with other types (classes) will “bubble up”

• This means that you must still declare a throw in the message header if you do not handle all exceptions that might occur .

• The most general type is simply “Exception”, the top-class of all exceptions: This will catch all possible exceptions.

• However, it is good to be specific. The compiler can only effectively tell you whether you have forgotten to handle some exception if your catch clauses and throw declarations are sufficiently specific.