Events and Exceptions

Analysis and Design of Embedded Systems and OO*

Object-oriented programmingJan Bendtsen

Automation and Control

Lecture Outline

Exceptions

Throwing and catching Exceptions

creating and throwing exceptions the try-catch() construct

Events

Simple file I/O

Streams, readers and writers The File Class java.io.Serializable

...

Error-prone activities

Consider a (C or similar) function that does the following:

void readFile() {

// Open a file;

// Determine its size;

// Allocate that much memory;

// Read the file into memory;

// Close the file;

}

Error-prone activities

Consider a (C or similar) function that does the following:

void readFile() {

// Open a file; - Oops! The file does not exist

// Determine its size; - Oops! The file size cannot be determined

// Allocate that much memory; - Oops! Out of memory!

// Read the file into memory; - Oops! File corrupted!

// Close the file; - Oops! Lost connection

}

Traditional error handling. . .

if (readFailed()) {

errorCode = -1;

}

} else {

errorCode = -2;

}

} else {

errorCode = -3;

. . .

}

return errorCode;

}

errorCodeType readFile {

errorCodeType errorCode = 0;

// Variable declarations

FILE fp == fopen(”MyFile.txt”,”r”);

if (fp != NULL) {

fileLength = getFileLength();

if (fileLength > 0) {

buffer = malloc(fileLength*sizeof(int));

if (buffer != NULL) {

// allocation went OK, read// the file into memory;

. . .

Traditional error handling

The actual code tends to drown in ”if (...) { ... } else { // error handling } ” constructs

The logical flow of the code is interrupted

=> it is easy to lose the overview (the error handling code may itself introduce errors)

=> it is easy to forget to handle errors (buggy software)

Exceptionscatch(FileOpenFailed) {

// Error handling for file opening

} catch(sizeDeterminationFailed) {

// Error handling for file size

} catch(memoryAllocationFailed) {

// Error handling for malloc

} catch(FileReadFailed) {

// Error handling for read failure

} catch(FileCloseFailed) {

// Error handling for lost conn.

// etc.

}

}

void readFile() {

try {

// Open a file;

// Determine its size;

// Allocate that much memory;

// Read the file into memory;

// Close the file;

}

. . .

Exceptions

Exceptions are objects generated when the normal program flow is interrupted

They are only generated when needed

They can be used to delegate information of a failure or other event to a place in your program that is geared to handle it, thus improving the robustness of your software

They don't save you any work

... but they can improve the readability and logical flow of your code quite a lot

Exceptions as classes

java.lang.Throwable

IOException

#msg: String+IOException()+IOException(String s)+getMessage()

project.io

FileOpenException

+getFileName()+getFile()

#filename: String

java.lang.Exception

Using exceptions

Exceptions are standard objects that must be a (possibly distant) subclass of java.lang.Exception

When somethings goes wrong, an exception object is created (using a constructor, just like any other object) and then either handled immediately or thrown

Once thrown, the program execution is halted

The exception is then passed down the call stack until an appropriate code segment is able to process them. This is called catching an exception

If an exception is not caught at some point, the program dies

Throwing exceptions

main

Method without error handler

Method where error occurs

Method with error handler

Generates and throws an exception

Looking forappropriatehandler

Looking forappropriatehandler

Catches exception

Forwards exception

Method calls

Throwing Exceptions in Java Where the exception occurs:

public double computeOutput(double input) throws SingularMatrixException {

if (D.isSingular()) { throw new SingularMatrixException(

“D is not invertible!”);}// Computations

...

In the invoking method:public Vector computeOutput(Vector inputs) throws SingularMatrixException {

...

for(Double input : inputs) { v.add(computeOutput(input.doubleValue()));

}

...

Catching Exceptions in Java Error handling code

public void compute() {...try {

Vector v = system.computeOutput(theValues);...

} catch (SingularMatrixException sme) {// Do the necessary to handle singular matrices

...}

Events

Events are similar to Exceptions, in that they are generated when “something happens”

They are typically generated in connection with user interaction, e.g., mouse clicks etc.

Unlike Exceptions, they are not thrown down the call stack, but rather handed over to an Event Listener which acts as an event handler;

If they are not caught, the program typically does not die

No try-catch construct, just ordinary method calls

Z

The Event Listener model

JMenu

JSpinner

JButton

Return

Space

UIWindow

SettingsManager

PlayerCharacter

Event listenersEvent sources

Events in Java

First thing to do is add one or more event listener objects to the event source object(s) involved:

public class Simulator extends JFrame implements ActionListener {

// Constructor

public Simulator() {JButton startBtn = new JButton(“Start”);JButton stopBtn = new JButton(“Stop”);startBtn.addActionListener(this);stopBtn.addActionListener(this);

...

This way, both startBtn and stopBtn are able to hand over Action events to the Simulator object.

Events in Java

In order to receive events, an appropriate event handling method must be implemented:

public class Simulator extends JFrame implements ActionListener {

...

public void actionPerformed(ActionEvent ae) {

String buttonLabel = ae.getActionCommand();

if (buttonLabel.equals(“Start”)) {

startSimulation();

} else {

stopSimulation();

}

}

UML

Simulator

-startButton: JButton-endButton: JButton

+actionPerformed(ActionEvent ae)-startSimulation()-stopSimulation()

JFrame ActionListener

File I/O in Java

I/O is abstracted to a high degree in Java

I/O is centered around the concept of streams

disk files

devices

other programs

memory arrays

...

They can be of different types

byte streams

character streams

object streams

Basic Streams

Reading datainto a program

Writing datafrom a program

Streams in Java Streams are, of course, objects

Programs typically use byte streams to perform input and output of 8-bit bytes

All byte stream classes inherit from InputStream and OutputStream

For instance, if the source/destination are files, one could use

FileInputStream

FileOutputStream

However, if we are working with text (i.e., characters), it is more convenient to use Reader and Writer objects

FileReader

FileWriter

Character-based I/O public static void main(String[ ] args) throws IOException {

FileReader in = null;

FileWriter out = null;

try {

in = new FileReader("xanadu.txt");

out = new FileWriter("outagain.txt");

int c;

// character by character...

while ((c = in.read()) != -1) { out.write(c); }

} finally {

if (in != null) { in.close(); }

if (out != null) { out.close(); }

}

}

Streams, Readers and Writers

Rather than having to work with raw bytes or individual characters, it is often convenient to wrap streams in formatted ”readers” and ”writers”:

try {input = new BufferedReader(new

FileReader("xanadu.txt"));output = new PrintWriter(new

FileWriter("characteroutput.txt"));String line;while ((line = input.readLine()) != null) {

output.println(line);}

} catch(FileNotFoundException e) {System.out.println(”Could not find file!”);

} ...

Streams, Readers and Writers

Physical file

Byte stream

Basic Reader

Formatted Reader

Program

File objects in Java The File class hides underlying OS-specific details from the user;

consider for instance

File fil = new File(“slides3.pdf”);

On a Linux system, fil.getAbsolutePath() might return

/home/dimon/javacourse/lecture3/slides3.pdf

On a Windows system, the same call might return

c:\My Documents\java\lecture3\slides3.pdf

By manipulating File objects, you can do various things to files existing in the file system

Delete files (fil.delete(); fil.deleteOnExit(); )

Change the modification date/time fil.setLastModified(new Date().getTime());

Rename files ( fil.renameTo(“slides13.ps”); )

java.io.Serializable

The interface java.io.Serializable allows writing objects to a (binary) stream:

public class Matrix implements Serializable { ...

Such objects are then read and written via ObjectInputStream and ObjectOutputStream objects, respectively:

try {

ObjectOutputStream oos = new

ObjectOutputStream(new FileWriter(“myfile.dat”));

oos.writeObject(this);

}

java.io.Serializable

Serializing objects should be used with some caution, as the writeObject() method automatically includes all object references known to the object in question in the bytes to be written to the stream, thus introducing a lot of overhead

If at all in doubt, write your own text-based content-saving methods

PlotDemo – this time with data loaded from disk

JButton

Click!

p(x)

FunctionPlotter(JFrame)

Polynomial

FileInput

paint()

coefficients

PolynomialGraph(JPanel)

Classes (Objects) in PlotDemo

JButton

Click!

Polynomial

p(x)

FunctionPlotter(JFrame)

PolynomialGraph(JPanel)

NumericalInput

paint()

coefficients