JAVA

prettybadelyngeSoftware and s/w Development

Nov 18, 2013 (3 years and 8 months ago)

57 views

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

1

JAVA


Developed at SUN by James Gosling
with support from Bill Joy


Net
-
based language


Descended from Oak

»
platform independent

»
object oriented

»
small


The Java Tutorial:

http://java.sun.com/docs/books/tutorial

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

2

Goals for Java


Simple

»
easy to learn


based on C/C++

»
small


Object oriented

»
single inheritance


Distributed

»
libraries supply
protocols

Robust

strongly typed

safe pointer model

Secure

Platform independent

virtual machine

Portable

no implementation
dependent data types

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

3

Goals for Java (cont.)


Compiled and interpreted


Multithreaded


Dynamic

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

4

Java Virtual Machine


Compiler translates Java into J
-
code


Stack
-
based virtual machine (JVM)


No undefined or platform specific data types


Other languages can be translated to J
-
code


Interpreter is lightweight, easy to implement

»
use widely available language, like C


J
-
code is highly optimized


J
-
code can be compiled on the fly

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

5

How it Works


The JVM may be

»
an interpreter

»
an applet viewer

»
a web browser

»
part of an OS


Classes could be loaded from
filesystem or over a network


JVMs use an environment variable,
CLASSPATH, to find byte code
(.class files) to execute

Java
source

Java
compiler
(javac)

J
-
code
(JVM byte codes)

Other classes

Native
code

Java
interpreter
(a JVM)

Platform
independent

e.g.,
AWT

Platform
dependent

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

6

Java combines benefits of


A strongly typed, OO language


Flexibility of an interpreted language

»
Lisp, Perl, Tcl


A smalltalk virtual machine with security
protection

»
Java byte code verifier reduces runtime checks


Package structure for organizing classes into
subsystems

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

7

Other benefits of Java


Exception handling


Support for multi
-
threading

»
Based on Hoare’s monitors


Highly optimized

»
Easy debugging


make debugging statements dependent on a constant
value, which programmer sets when done debugging


compiler automatically removes unexecutable statements

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

8

Three levels of Security


Security manager

»
controls access to system resources

»
highlight windows of untrusted applications


Class loader

»
restricts classes loaded from network to interact
with classes from the same location


Verifier

»
checks that incoming classes can’t forge pointers,
violate access permissions, over/under flow
operator stack, etc.

»
ensures type safety

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

9

Java doesn’t have


Macros and preprocessor

»
mostly used for platform dependencies


Operator overloading, except for +


(Very many) automatic type coercions


Pointer arithmetic

»
references are a higher level type and can only
point to class objects, not to class methods


Explicit memory management

»
provides automatic garbage collection

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

10

Java and the Web


A web browser can incorporate a JVM and
run Java applets as executable code


Life of an applet

»
Loaded by a web browser and asked to initialize
itself

»
Informed each time it is displayed and hidden

»
Informed when it is no longer needed


Security manager prevents applet from
accessing system resources or interacting
with outside applications

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

11

Java classes


Class is the basic computation unit

»
encapsulates data and associated operations

»
found and loaded dynamically as needed


22 architecture specific classes: “gateway to
the real world”

»
networking, windowing, filesystem, etc.


Rest of Java is written in Java

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

12

Inheritance in Java


Single inheritance hierarchy


Multiple inheritance of interfaces

»
Interface specifies the operations but not the
implementations

»
A class can “implement” multiple interfaces

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

13

Java coding conventions


Class names begin with upper case letters


Variables and method names begin with
lower case letters


Constants are all upper case


Separate words with uppercase letter instead
of underscores

e.g. aVariableName AClassName



aMethodName ACONSTANT



Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

14

Classes in Java


Define an abstract data type

»
operations called
methods

»
data called
variables

or
fields


Many class
instances

or
objects
can exist

»
each instance may have a different
state


e.g., different values for variables

»
all instances have the same methods


Arranged in a hierarchy

»
each class has a unique
superclass
(parent)

»
subclass

(child) can add or modify methods or variables of
the superclass

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

15

Variables in Java


Maintain
state

of a class instance


Belong to some class or class instance

»
static variable
--

one per class

»
instance variable
--

one per class instance


All variable values are by reference

»
point to their values, which are maintained on a
heap

»
Initial value is
null

»
access to null value raises the
NullPointerException

exception

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

16

A simple Java applet

import java.applet.Applet;

import java.awt.Graphics;

public class Simple extends Applet {


StringBuffer buffer;


public void init( ) {


buffer = new StringBuffer( );


addItem(“initializing …”);


}


public void start( ) {


addItem(“starting …”);


}




Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

17

A simple Java applet (cont.)


public void stop( ) {


addItem(“stopping …”);


}


public void destroy( ) {


addItem(“starting …”);


}


public void addItem(String newWord ) {


System.out.println(newWord);


buffer.append(newWord);


repaint( );


}






Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

18

A simple Java applet (cont.)


public void paint (Graphics g) {


//Draw a rectangle around the applet’s display area


g.drawRectangle(0, 0, size( ).width
-
1, size( ).height
-
1);




//Draw the current string inside the rectangle


g.drawString(buffer.toString( ), 5, 15);


}


}


Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

19

Lifetime of an Applet

running

stopped

load/init( );start( );

leave page/stop( )

return to page/start( )

iconify/stop( )

de
-
iconify/start( )

quit/destroy( )

reload/stop( ); destroy( ); init( )

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

20

Part of the Java Class Hierarchy

Object

Component

Container

Button

Window

Panel

Applet

Simple

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

21

Subclassing and Inheritance


A
subclass

extends, refines, or specializes a
superclass


A subclass can extend only one superclass


A subclass
inherits

the public methods and
variables from its superclass

»
Does not inherit private members (in Java)


The subclass is considered a
subtype

of the
superclass

»
All visible superclass operations apply to subclass

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

22

Subclassing Example

Container

Window

Panel

Applet

Simple

Container( )

add(Component)

doLayout( )

getComponent(int)

paint(Graphics)

print(Graphics)

remove(Component)
. . .

Panel( )

Panel(Layout)

addNotify( )

Applet( )

init( )

start( )
. . .


getImage(URL, String)

getParameter(String)

play(URL)

. . .

init( )

start( )

stop( )

destroy ( )

paint (Graphics)

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

23

Interfaces in Java


An interface class describes a protocol of behavior

»
Members are constants and abstract methods

»
Abstract methods have no implementations


Can be
implemented

by any class anywhere in the
class heirarchy

»
Cannot be instantiated

»
Implementing classes agree to implement all methods
declared in the interface

»
Class can implement multiple interfaces

»
Interface can be implemented by multiple classes


Does not force a class relationship

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

24

Interface Example


Objects can register themselves with an AlarmClock
object to be woken up after some specified time

»
Objects call the letMeSleepFor method:

public synchronized boolean letMeSleepFor( Sleeper theSleeper, long time)

{


int index = findNextSlot ( );


if (index == NOROOM) {


return false;


} else {


sleepers[ index ] = theSleeper;


sleepFor[ index ] = time;


new AlarmThread( index ).start( );


return true;


}

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

25

Interface Example (cont.)


An object that wants to use AlarmClock must
implement the wakeUp method

»
This is enforced by the type of theSleeper

Public interface Sleeper {


public void wakeUp ( );



public long ONE_SECOND = 1000; // in milliseconds


public long ONE_MINUTE = 60000; // in milliseconds

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

26

Interface Example (cont.)


Any object that implements this interface can
be passed to letMeSleepFor

Class GUIClock extends Applet implements Sleeper {


. . .


public void wakeUp ( ) {


repaint ( );


clock.letMeSleepFor( this, ONE_MINUTE);


}

}

GUIClock updates its display every minute (showing the
current time)

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

27

Abstract class v.s. Interface class


Why not use an abstract class for Sleeper?

Abstract class Sleeper {


public abstract void wakeUp ( );

}

Only objects that are subclasses of Sleeper would be able
to use AlarmClock

Conceptually, AlarmClock should not force a class
relationship on its users

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

28

Exceptional Conditions


Handling exceptional conditions can more
than double the size of the code


Systems can respond to errors in many ways

»
crash

»
give error message and crash

»
give error message and let user retry


minimize work that must be redone


allow user to decide how much work must be redone

»
correct the error


allow user to confirm that correction is valid

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

29

Approaches for Handling Exceptional
Conditions


Each method handles the exceptional
conditions that arise during its execution


A low level class/method handles all
exceptional conditions that may arise


All methods return status information so that
client methods can respond to exceptional
conditions


ALL OF THESE APPROACHES HAVE PROBLEMS

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

30

I. Each method handles its own
exceptional conditions

info1

(in case an exception arises)

info1, info2

(in case an exception arises)

Code to detect and handle
exception

Code to detect and handle
exception (use info1, info2)

Code to detect and handle
exception (use info1)

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

31

I. Each method handles its own
exceptional conditions


No modularity or consistency

»
changes to error handling affect all the methods


May need to pass considerable information
many levels to maintain context information

»
hard to provide user friendly response w/o
knowing clients context


Must return status information so calling
method can determine if it should proceed or
terminate

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

32

II
.
A low level class/method handles
exceptional conditions

Exception handling class

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

33

II
.
A low level class/method handles
exceptional conditions




Error processing handled in a more consistent and
modular fashion

»
changes to error handling only affect the error handling
class/method


May need to pass considerable information many
levels to maintain context information

»
hard to provide user friendly response w/o knowing clients
context


Must return status information so calling method can
determine if it should proceed or terminate

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

34

III. Methods return status information so that
client methods can respond to exceptional
conditions


Calling method must always check status
information


Calling methods must be able to respond to
status information

call Foo(bar, status1, status2, …, statusN);

if status1 then


do repair1;

else if status2 then


do repair2;

else if . . .

else


normal processing using bar

endif

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

35

Exceptions were added to languages to
help with error processing


A method that detects a problem can handle the
exception locally and then
raise/throw/signal

an
exception to the methods in its calling context

throw E1

handler for E1

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

36

A method can catch an exception and
specialize its response

throw E1

handler for E2

handler for E1;

throw E2

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

37

Exception Handling Mechanisms


Signal/raise/throw an exception

»
predefined

»
user defined


Exception handlers

»
local

»
non
-
local


propagate through call stack


one level only


multiple levels

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

38

Exception Handling Mechanisms
(cont.)


Execution after handler

»
resumption model: return to signal location

»
termination model: terminate execution of method


Java supports predefined and user defined
exceptions, local and multi
-
level propagation,
with termination

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

39

Exceptions in Java


Indicates an unusual situation (error)


Thrown at the point in the code where the
error occurs


Caught by an exception handler

»
Can be handled locally

»
Can look back through call stack for the first
handler


Methods must declare the exceptions they
throw

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

40

Handling Exceptions

try

{


i = s.pop( );

}


catch( EmptyStackException i);


{


system.out.println(


“Oops! The stack is empty!” );


i = 0;

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

41

Handling multiple exceptions

try

{


readFromFile( “foo” );

}

catch( FileNotFoundException e);

{


system.out.println(


“Oops! The file is missing!” );

}

catch( IOException e )

{


system.out.println(


“Oops! Can’t read the file!” );

}

finally

{


readFromFile( “foo.bak”);

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

42

Try/Catch Statement


Exceptions raised in the try body are handled in the
catch statements


Catch statements are evaluated in order

»
first match leads to execution of the catch body


Usually list exceptions from most specific to least
specific


If there is a finally clause then it is always executed


May not execute all statements in try body

»
could be interrupted by an exception

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

43

Finding Exception Handlers


Look in enclosing blocks


Look in calling methods


If no exception handler is found in call stack, program
crashes

throw E1

handler for E1

propagate E1

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

44

Multiple Levels of Propagation

getContent( _)

{


try {


openConection( ); readData ( );


}


catch (IOException e) {


//handle IO error


}

}

openConnection ( ) throws IOException

{


openSocket( ); sendRequest( );


….

}

sendRequest ( ) throws IOException

{


write (body); //write error

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

45

Explanation


Write throws the exception


sendRequest doesn’t handle the exception but must
indicate that it propagates the exception


Same for openConnection


getContent catch statement handles the exception


May never execute the readData( ) statement in
getContent

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

46

Throwing Exceptions

int Dequeue (Queue q) throws QueueEmpty

{


if ( q.head == q.tail )


{


throw new QueueEmpty ( );


}


else


{


q.head = q.head + 1;


return q.contents [q.head
-

1];


}

}


class QueueEmpty extends Exception

{

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

47

Types of Java Exceptions


General exceptions

»
Must be explicitly thrown

»
Should be handled by all programs


Runtime exceptions

»
Frequent runtime problems

»
No need to explicitly state that such an exception
might be thrown

»
Runtime message generated if they are not
caught

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

48

Summary of Exception Handling


Exceptions allow the programmer to separate the
handling of unusual cases from expected ones


Program should catch predefined exceptions and
throw more specific exceptions when possible


Exception handling is difficult, even with exception
handlers


Exception handling is an important part of most
programs

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

49

Concurrent System


Multiple
threads

of execution

»
Logically concurrent: share a single processor

»
Physically concurrent: multiple processors


Run independently, for the most part


Typically, need to communicate

»
Share data

»
Pass messages


Typically, need to synchronize their activities

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

50

Threads in Java


A thread is a sequential flow of control within
a program

»
has a beginning, an execution sequence, and an end

»
cannot be run on its own, but exists only within a larger
program

A program
with three
threads

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

51

Defining the behavior of a thread


The behavior of a thread in Java is given by
a special method

»
the
run

method


Two techniques for providing a run method
for a thread

»
Subclass
Thread

and override the
run

method

»
Implement the
Runnable

interface

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

52

Defining thread behavior: Subclassing
Thread


A thread that computes names larger than a given value

class PrimeThread extends Thread {


long minPrime;


PrimeThread ( long minPrime ) {


this.minPrime = minPrime;


}


public void run ( ) {


// compute primes larger than minPrime


. . .


}

}


Code to create a PrimeThread thread and start running it:

PrimeThread p = new PrimeThread(143);

p.start ( );

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

53

Defining thread behavior: Implementing
runnable

class PrimeRun implements Runnable {


long minPrime;


PrimeRun ( long minPrime ) {


this.minPrime = minPrime;


}


public void run ( ) {


// compute primes larger than minPrime


. . .


}

}


Code to create a PrimeThread thread and start running it:

PrimeRun p = new PrimeRun(143);

new Thread( p ).start ( );


A thread that computes names larger than a given value

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

54

When should you implement
Runnable?


If a class needs its own thread and must
subclass some other class, you should
implement Runnable

»
Example: Suppose you want an applet that
displays the time, updating it every second


It has to subclass Applet to run in a browser


It needs its own thread in order to continuously update its
display without taking over the process that its running in

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

55

Life Cycle of a Thread in Java

new

new Thread ( . . . )

running

start ( )

executing

waiting

not runnable

stopped

run method terminates


Transitions to
not runnable

»
invokes its
sleep

method

»
invokes a
wait

method for
some condition

»
blocks on an IO operation


Transitions to
running

»
specified time elapses

»
notify

method is invoked to
signify the condition is met

»
the IO operation completes

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

56

Synchronizing Threads in Java


A
lock

is associated with objects containing
synchronized

methods

»
The object is locked when a thread enters one of
its synchronized methods

»
Other threads cannot enter a synchronized
method on the same object until the object is
unlocked


Lock is acquired and released automatically
by the Java Runtime System

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

57

Synchronizing Threads in Java
(cont.)


Threads that use synchronized methods are
coordinated using
wait

and
notify
(or
notifyAll
)

»
Invoking the
wait

method blocks the thread
and releases the lock

»
An object invokes
notify

to wake up a
thread that is waiting on it

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

58

Producer/Consumer Example



public class CubbyHole {


private int contents;


private boolean available = false;



public synchronized int put ( ) {


//CubbyHole is locked by the Producer


. . .


//CubbyHole is unlocked by the Producer


}



public synchronized int get ( ) {


//CubbyHole is locked by the Consumer


. . .


//CubbyHole is unlocked by the Consumer


}

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

59

Producer/Consumer Example (cont.)

public synchronized int get ( ) {


while ( available == false ) {


try {


// wait for Producer to put value


wait ( );


} catch ( InterruptedException e) {


}


}


available = false;


// notify Producer that value has been retrieved


notifyAll ( );


return contents;

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

60

Producer/Consumer Example (cont.)

public synchronized void put ( int value ) {


while ( available == true ) {


try {


// wait for Consumer to get value


wait ( );


} catch ( InterruptedException e) {


}


}


contents = value;


available = true;


// notify Consumer that value has been set


notifyAll ( );

}

Dillon: CSE470: JAVA, EXCEPTIONS & THREADS

61

Concurrency Summary


A thread is a sequential flow of control


Multiple threads execute concurrently within
the same program


Objects with
synchronized

methods
implement monitors

»
monitors use the
wait

and
notify

methods to
coordinate the activities of the threads that they
serve