Week12

Week 12
Exceptions and
File I/O

Copyright Warning
COMMONWEALTH OF AUSTRALIA
Copyright Regulations 1969
WARNING
This material has been copied and communicated to you by or
on behalf of Bond University pursuant to Part VB of the
Copyright Act 1968 (the Act).
The material in this communication may be subject to copyright
under the Act. Any further copying or communication of this
material by you may be the subject of copyright protection
under the Act.

Do not remove this notice.

© 2004 Pearson Addison-Wesley. All rights reserved 10-2

Methods Return Values
• We have seen that programs are usually broken
into modules:
 Classes provide a set of attributes that a collection of
“things” have in common, even if they have different
values
 Methods provide access to class attributes
 Methods also allow a large problem to be broken into
several sub-task, and each method provides one sub-task
• Methods are passed input parameters
• Methods work on their inputs, possibly call other
methods, and can return one value to their caller
• But what do we do if there isn't a value to return?


Consider the Scanner Class
• The Scanner Class reads input from the user.
• Actually, it reads lines of text from somewhere,
and converts the text into something else, e.g.
 scan.nextInt() reads in the next integer from the line
of input text
• So, we can do this:
System.out.print(“What is your age: ”);
age= scan.nextInt();
• What happens when the user types a word instead
of a set of digits?
• What int value will the nextInt() method
return?
 We can't use a specific int value to indicate error. Why
not?

We Need Two Types of Return Values
• We can't return a normal value to the caller of a
method, yet we want them to know that something
went wrong
• Many languages, including Java, allow a method to
return two types of things back to the caller:
 A return value, which is what usually happens, or
 An Exception, which informs the method caller that there
is no return value, and something went wrong
• A method can only send back one of these things,
not both
• A method caller can choose to receive either or
both of these things, or ignore either or both too


Exceptions: Visually

nextInt()

return(num);

Throw Exception;


Exceptions
• An exception is an object that describes an
unusual or erroneous situation

• Exceptions are thrown by a program, and may be
caught and handled by another part of the
program

• A program can be separated into a normal
execution flow and an exception execution flow

• Java also has a related thing called an error

• An error is also represented as an object in Java,
but usually represents a unrecoverable situation
and should not be caught

Exception Handling
• Java has a predefined set of exceptions and errors
that can occur during execution
 And you can make your own up to suit your situation

• A program can deal with an exception in one of
three ways:
 ignore it
 handle it where it occurs
 handle it an another place in the program

• The manner in which an exception is processed is
an important design consideration
• Try to handle an exception where you can recover
from it

Exception Handling
• If an exception is ignored by the program, the
program will terminate abnormally and produce
an appropriate message

• The message includes a call stack trace that:
 indicates the line on which the exception occurred

 shows the method call trail that lead to the attempted
execution of the offending line


Ignoring an Exception
System.out.print(“What is your age: ”);

What is your age: none of your business

InputMismatchException: next item is not an
integer at Scanner.nextInt()

(program stops)


Outline
Exception Handling
The try-catch Statement
Exception Classes
I/O Exceptions


Catching Exceptions: The try Statement
• To handle an exception in a program, the line that
throws the exception is executed within a try block

• A try block is followed by one or more catch
clauses

• Each catch clause has an associated exception
type and is called an exception handler

• When an exception occurs, processing continues
at the first catch clause that matches the
exception type


An Example
try
{
System.out.print("What is your age: ");
}
catch (InputMismatchException e)
{
System.out.println("You didn't type a number");
System.out.println("Java says: " + e);
}

• Note that e is an object declared as part of the catch
line, and it is an object of the InputMismatchException
class

Class Question
try
{
System.out.print("What is your age: ");
}
catch (InputMismatchException e)
{
System.out.println("You didn't type a number");
System.out.println("Java says: " + e);
}

• How do we modify the above so that it loops until the
user does enter an integer value?


The finally Clause
• A try statement can have an optional clause
following the catch clauses, designated by the
reserved word finally

• The statements in the finally clause always are
executed

• If no exception is generated, the statements in the
finally clause are executed after the statements in
the try block complete

• If an exception is generated, the statements in the
finally clause are executed after the statements in
the appropriate catch clause complete


Input/Output and Exceptions
• Let's examine issues related to exceptions and I/O

• A stream is a sequence of bytes that flow from a
source to a destination

• In a program, we read information from an input
stream and write information to an output stream

• A program can manage multiple streams
simultaneously

• Streams can be connected to the keyboard, the
terminal, or to/from files on the computer, and
even network connections


Standard I/O
• There are three standard I/O streams:
 standard output – defined by System.out
 standard input – defined by System.in
 standard error – defined by System.err

• We use System.out when we execute println
statements
• System.out and System.err typically represent a
particular window on the monitor screen
• System.in typically represents keyboard input,
which we've used many times with Scanner
objects


The IOException Class
• Operations performed by some I/O classes may
throw an IOException
 A file might not exist

 Even if the file exists, a program may not be able to find it

 The file might not contain the kind of data we expect


Writing Text Files
• Java provides a whole pile of classes to deal with
I/O. In fact, there’s a complex hierarchy of classes
• We are going to look at how to get access to text
files, in a way that allows you to use println()
and friends
• Text files are files made up entirely of plain text.
They could be:
 Plain text .txt files

 Comma-separated value .csv files

 Web documents , i.e. .html files


Writing Text Files
• In order to use a text file, we must open it for
writing. This gives us exclusive access to the file:
PrintWriter outFile;
String filename= “myfile.txt”;
try
{
outFile= new PrintWriter(
new BufferedWriter(
new FileWriter(filename)));
}


Writing Text Files
• Opening a file can throw an IOException for many
reasons, so we must try { … } catch{ … } it
• Once the file is open, we can use the outFile
object (of class PrintWriter) as we would use
System.out:
outFile.println(“Hello, how are you?”);

outFile.print(“The variable x is ” + x);

• We must close the file when we’re finished, to let
other users or programs access the file:
 outFile.close();


Reading Text Files
• Just as with writing a text file, we must open a file
for reading. This stops other users or programs
from trying to write to the file at the same time
Scanner inScan;
String filename= “myfile.txt”;
try
{
inScan= new Scanner(
new FileReader(filename));
}
• And of course a catch { … } clause


Reading Text Files
• After that, you can use the nextInt(),
nextDouble(), nextline() methods on the
inScan object
• The Scanner class also has a set of methods that
allow you to find out if there is any input of a
certain type left:
 inScan.hasNextLine()
 inScan.hasNextInt()
 inScan.hasNextDouble()
• We also need to close the input file once we are
done with it
 inScan.close()


Week12

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (8)

Similar to Week12

Similar to Week12 (20)

More from hccit

More from hccit (20)

Recently uploaded

Recently uploaded (20)

Week12