1

Object Oriented ProgrammingLecture IV

Design Patterns, The Observer Observable Pattern, Some notes on Enumeration Types, I/O

Streams and Exceptions

2

Short Recapitulation of Last Lecture

• We talked about– Inheritance and reusal

• A few different aspects on reusability• Overriding vs. Overloading

– Interfaces– Abstract classes– Polymorphism– Packages

• Also usable for name (Class) collision

3

Today

• What is a design pattern?

• A first design pattern– Observer Observable

• Throwables and Exceptions

• Type Enumeration

4

Design Pattern - What is it?

• A design pattern is a descriptive solution that can be used systematically to solve a recurring problem– Can be applied in many engineering disciplines

• Why are design patterns useful?– 1. A number of patterns that can be used as

guidance, during the design phase of a program– 2. Reusage of proved solutions, for fast and reliable

software development– 3. A common vocabulary to simplify communication

between designers.

5

The Pen Object Example

What functionality do we want when using a pen(interface)?

Constructorpen()

Methods for changing the state of a pen(instance methods)void lift()void push()void move(double d)void turn(double alpha)

Methods for assigning a drawing area to our penvoid setPaper(Paper p)

6

Pen is a Mutable ObjectPen thePen;... public void recLine(int n, double length){ if (n==0) thePen.move(length); else{ int m = n-1; double shorter = length/3.0; double alpha = Math.PI/3; recLine(m,shorter); thePen.turn(-alpha); recLine(m,shorter); thePen.turn(2*alpha); recLine(m,shorter); thePen.turn(-alpha); recLine(m,shorter); } }

Modifies the state of the pen itself. Pen is mutable

7

Let’s take a look atmove(double d)

public void move(double d){double oldx = x;double oldy = y;

x = Math.min(x+d*Math.cos(alpha),paper.width());y = Math.min(y+d*Math.sin(alpha),paper.height());

if(down)paper.drawLine((int)oldx,(int)oldy,(int)x,(int)y);

}

8

Our first design pattern:Observer-Observable

• Now, let’s examine the properties of a Paper

width

height

A paper is a Canvas that has height and width dimensions in pixels. It also has a paint method to show the lines drawn by the Pen.

Canvas is an AWT component

9

Observer – ObservableSeparation of Model and View• Paper (Model)

– Add a new line– Width– Height

– Add Observer– Register changes – Notify the Observers

• Paperview (View)– Override the paint

method so that it paints the state of the model (lines)

– Define the method update so a change in the model will be reflected in the view

10

Extending Observable

• The Observable class implements methods for attaching to, and interacting with a set of Observers– method to add Observers to the Set– method to notify Observers of changes by calling the

Observers update method

• By extending Paper with Observable, we will inherit this mechanism and gain access to necessary methods

• We only need to know which are the Observers

11

The Paper Class: Observable

public class Paper extends Observable{ private Vector lines; private int width, height; … public Paper(int width, int height){ this.width = width; this.height = height; lines = new Vector(); }

public void drawLine(int a, int b, int c, int d){ lines.add(new Line(a,b,c,d)); setChanged(); notifyObservers(); } ...

Register the change in Observer!

Notify the Observers!

We have added a line...

12

The PaperView Classpublic class PaperView extends Canvas implements Observer{ private Paper paperModel; public PaperView(Paper p){ paperModel = p; paperModel.addObserver(this); … }

public void update(Observable o, Object arg){ try{Thread.sleep(200);}catch(Exception e){} repaint(); } public void paint(Graphics g){ Iterator iter = paperModel.iterator(); while(iter.hasNext()){ Line line = (Line)iter.next(); g.drawLine(line.v, line.w, line.x, line.y); } }}

Called when notifying observers!

How we paint the lines!

13

A few things about Throwables & Exceptions

• Exceptions are/should be generated when unexpected or faulty conditions occur in a program

• When a fault occurs, an exception can be thrown and the normal program flow is interrupted

• There are three kinds of Throwables:– Error (severe)– RuntimeException (for example ”array out of bounds”)– Exception (User defined exception should extend this)

14

Exceptions

Throwable

Error

Exception

OutOfMemoryError

AssertionError

Serious Fault!

RuntimeException

Io-Exception

ArithmeticException

ClassCastException

IndexOutOfBoundsException

NullpointerException

Thrown By JVM!

Any program!

15

Catching Exceptions

Exceptions are caught & handled with a ”try-catch-clause”:

Try{a = b[i];

}catch (ArrayOutOfBoundsException e){”exception handling code here...”

}finally{...clean up before leaving} (...finally is not necessary)

User defined exceptions must extend class Exception:MyVeryOwnException extends Exception{

super(”A terrible error has occured!”);}

16

Throwing Exceptions

• Most Exceptions are thrown by the JVM• But Exceptions can also be thrown anywhere in a

program:Public int example(void) throws MyException{

”method code...”throw new MyException();

}

• Method calls to methods that has a throws statement must be encapsulated with ”try-catch” clause

• The exception should be handled in ”catch” or be thrown to the object that was calling the method.

17

The Java I/O Framework

• The I/O framework is designed with intention to be flexible and easy to configure

• Java has two main types of I/O:– Stream IO

• Supports reading/writing sequentially• A stream can only be open for read or write, not both

– Random Access I/O• Reading and writing at any position in a file• File I/O can be open both for read/write

• Two kinds of streams– bytes or character streams

18

I/O Byte Streams

• The basic I/O streams are:– Input Stream

• read(); - reads byte• read(byte[] a); - reads byte array• read(byte[] a, int off, int len); - reads part of byte array• skip(long n); - skips over n bytes• close(); - closes the stream

– OutputStream• write(b); - writes byte• write(byte[] a); - writes byte array• write(byte[] a, int off, int len); - writes part of byte array• close(); - closes the stream

19

Reading from files

• FileInputStream and FileOutputstream are sub classes of Input and OutputStream byte streams (overloads methods)

• Byte streams are hardly convenient to use directly, requires very ”low-level manipulation”– bitmasking and type conversion

• This kind of ”low-level” streams are rarely necessary– most data are represented by Objects

20

Buffered Streams

• BufferedInputStream and BufferedOutputStream (extends java.io.FilterInputStream)– reads data via an ”internal” buffer (JVM managed)

• BufferedReader and BufferedWriter (extends java.io.Reader)– abstract streams that we can use for reading

string/character data– can be used to read entire Strings

21

Object serialization

• Java supports object serialization– objects can be passed as arguments to a stream– the objects are ”transparently” serialized to a

sequence of bytes

• Objects must implement the Serializable interface (java.io.Serializable)

• ObjectInputStream and ObjectOutPutStream– FileInputStream/FileOutPutStream as arguments for

file reading

22

Enumeration Types

• Enumeration types, what is it?– it is a finite set of distinct user defined values

• Example of Enumerated types: – Date = Mon|Tue|Wed|Thu|Fri|Sat|sun– Direction = North|East|South|West

• We can use the Enumerated types like any other type in our program– Ex. Date d = Monday;

• The Enumerated types should be type safe

23

Enumerated types• Some languages like C/C++ support enumerated types...• In C or C++, we would write:

enum Date {Mon,Tue,Wed,Thu,Fri,Sat,Sun};Date day1 = Tue;Date day2 = Fri;If(day1 == day2){....}

• Untill Java 1.5 was released, Java didn’t support typesafe enumeration types

• Before 1.5 a common (but bad) solution: Treat enumeration types as static int constants.

24

A Type safe Idiom

• Type safe enumeration idiom– each value will be distinct (unique)– a printable, descriptive name rather that just an

Integer number

• Let’s look at an example– an ”unordered” Type-Safe Enumeration

• In the book, you can also find – an ”ordered” Type-Safe Enumeration

25

Typesafe enumeration is supported in Java 1.5

Public class Card{public enum Rank { Deuce, Three, Four, Five, Six, Seven,

Eight, Nine, Ten, Jack, Queen, King, Ace}

public enum Suit{ Clubs, Diamonds, Hearts, Spades }

private final Rank rank;private final Suit suit;

private Card(Rank r, Suit s){rank = r; suit = s;

}

public toString();}