Transcript Slides (PPTX)

Week 1 - Friday



What did we talk about last time?
Basic programming model
Other Java stuff
 References
 Static
 Inner classes
 Exceptions




Java handles errors with exceptions
Code that goes wrong throws an exception
The exception propagates back up through
the call stack until it is caught
If the exception is never caught, it crashes the
thread it's running on, often crashing the
program

There are two kinds of exceptions:
 Checked
 Unchecked

Checked exceptions can only be thrown if the
throwing code is:
 Surrounded by a try block with a catch block
matching the kind of exception, or
 Inside a method that is marked with the keyword
throws as throwing the exception in question

Unchecked exceptions can be thrown at any
time (and usually indicate unrecoverable
runtime errors)

Checked exceptions





FileNotFoundException
IOException
InterruptedException
Any exception you write that extends Exception
Unchecked exceptions




ArrayIndexOutOfBoundsException
NullPointerException
ArithmeticException
Any exception you write that extends Error or
RuntimeException
Scanner in = null;
try {
in = new Scanner( file );
while( in.hasNextInt() )
process( in.nextInt() );
}
catch( FileNotFoundException e ) {
System.out.println ("File " +
file.getName () + " not found !");
}
finally { if( in != null ) in.close (); }


In Java, concurrency and parallelism are
achieved primarily through threads
A thread is a path of code execution that runs
independently of others
 But threads can share memory with each other
 Some other languages use message passing
semantics and no direct memory sharing

To create a customized thread in Java, there
are two routes:
 Create a class which is a subclass of Thread
 Create a class which implements the Runnable
interface


If you subclass Thread, you can't subclass
some other object
If you implement Runnable, there's an
extra bit of syntax to create a new thread
public class
private
private
private
private
Summer extends Thread {
double[] array;
int start;
int end;
double result = 0.0;
public Summer(double[] array,
int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
public void run() {
for( int i = start; i < end; i++ )
result += array[i];
}
}
public double getResult() { return result; }
public double findSum( double[] array, int threads )
throws InterruptedException {
Summer[] summers = new Summer[threads];
double result = 0.0;
int step = array.length / threads;
if( array.length % threads > 0 ) step++;
for( int i = 0; i < threads; i++ ) {
summers[i] = new Summer(array, i*step,
Math.min((i+1)*step, array.length));
summers[i].start();
}
for( int i = 0; i < threads; i++ ) {
summers[i].join();
result += summers[i].getResult();
}
}
return result;



Keep it simple
Do not share data via static variables
Be careful with load balancing
 If the work is not evenly divisible by n (the number
of threads), give the first n – 1 threads one extra
piece of work
 Why?

Be aware that threading out a program will
not necessarily make it faster



Members
Methods
Why are they useful?
Monolitihic
main()
function
Work
divided into
functions
• Code and data
together
• Code
separated, but
data shared
Objects
• Code and data
separated

A template or prototype for an object
Class:
Human
Class:
Company
Object:
David Bowie
Object:
Microsoft
Object:
Barack
Obama
Object:
Boeing





Encapsulation
Dynamic dispatch
Polymorphism
Inheritance
Self-reference
Information hiding
We want to bind operations and data tightly
together
 Consequently, we don't want you to touch our
privates
 Encapsulation in Java is provided by the
private and protected keywords (and also
by default, package level access)
 Hardcore OOP people think that all data should
be private and most methods should be public


public class A
{
private int a;
public int getA()
{
return a;
}
}
public void setA(int value)
{
a = value;
}




Allows code reuse
Is thought of as an is-a relationship
Java does not allow multiple inheritance, but
some languages do
Deriving a subclass usually means creating a
"refined" or "more specific" version of a
superclass
public class B extends A
{ //has member and methods from A
}
public class C extends A
{
//has A stuff and more
private int c;
public int getC(){ return c; }
void increment() { c++; }
}



A confusing word whose underlying concept
many programmers misunderstand
Polymorphism is when code is designed for a
superclass but can be used with a subclass
If BMW235i is a subtype of Car, then you
can use an BMW235i anywhere you could use
a Car
//defined somewhere
public void drive( Car car )
{
…
}
public class BMW235i extends Car
{
…
}
Car car = new Car();
BMW235i bimmer = new BMW235i();
drive( bimmer ); //okay
drive( car ); //okay


Polymorphism can be used to extend the
functionality of an existing method using
dynamic dispatch
In dynamic dispatch, the method that is
actually called is not known until run time
public class A {
public void print()
{
System.out.println("A");
}
}
public class B extends A {
public void print() {
System.out.println("B");
}
}
A a = new A();
B b = new B(); // B extends A
A c;
a.print(); // A
b.print(); // B
c = a;
c.print(); // A
c = b;
c.print(); // B



Objects are able to refer to themselves
This can be used to explicitly reference
variables in the class
Or, it can be used to provide the object itself
as an argument to other methods
public class Stuff
{
private int things;
public void setThings(int
things)
{
this.things = things;
}
}
public class SelfAdder
{
public void addToList(List list)
{
list.add(this);
}
}



Java provides syntax that allows you to call
another constructor from the current class or
specify which superclass constructor you
want to call
The first line of a constructor is a call to the
superclass constructor
If neither a this() or a super()
constructor are the first line, an implicit
default super() constructor is called
public class A {
private double half;
public A(int value){
half = value / 2.0;
}
}
public class B extends A {
public B(int input) {
super(input); // calls super constructor
}
}
public B() {
this(5); // calls other constructor
}




An interface is a set of methods which a class
must have
Implementing an interface means making a
promise to define each of the listed methods
It can do what it wants inside the body of
each method, but it must have them to
compile
Unlike superclasses, a class can implement as
many interfaces as it wants


An interface looks a lot like a class, but all its
methods are empty
Interfaces have no members except for
(static final) constants
public interface Guitarist {
void strumChord(Chord chord);
void playMelody(Melody notes);
}
public class RockGuitarist extends RockMusician
implements Guitarist {
public void strumChord( Chord chord ) {
System.out.print(
"Totally wails on that " +
chord.getName() + " chord!");
}
}
public void playMelody( Melody notes ) {
System.out.print(
"Burns through the notes " +
notes.toString() +
" like Jimmy Page!" );
}


A class has an is-a relationship with interfaces
it implements, just like a superclass it extends
Code that specifies a particular interface can
use any class that implements it
public static void perform(Guitarist
guitarist, Chord chord, Melody notes)
{
System.out.println("Give it up " +
"for the next guitarist!");
guitarist.strumChord( chord );
guitarist.playMelody( notes );
}
Allow classes, interfaces, and methods to be written
with a generic type parameter, then bound later
 Java does the type checking (e.g. making sure that
you only put String objects into a
List<String>)
 After typechecking, it erases the generic type
parameter

 This works because all classes extend Object in Java


Appears to function like templates in C++, but works
very differently under the covers
Most of the time you will use generics, not create
them


You can make a class using generics
The most common use for these is for
container classes
 e.g. you want a List class that can be a list of
anything

JCF is filled with such generics
public class Pair<T> {
private T x;
private T y;
public Pair(T a, T b ) {
x = a;
y = b;
}
public T getX() { return x; }
public T getY() { return y; }
public void swap() {
T temp = x;
x = y;
y = temp;
}
}
public String toString() {
return "( " + x + ", " + y + " )";
}
public class Test {
public static void main(String[] args)
{
Pair<String> pair1 =
new Pair<String>("ham", "eggs");
Pair<Integer> pair2 =
new Pair<Integer>( 5, 7 );
pair1.swap();
System.out.println( pair1 );
System.out.println( pair2 );
}
}
Java Collections Framework





Collection
Iterable
List
Queue
Set
 SortedSet

Map
 SortedMap








LinkedList
ArrayList
Stack
Vector
HashSet
TreeSet
HashMap
TreeMap

Collections






sort()
max()
min()
replaceAll()
reverse()
Arrays
 binarySearch()
 sort()


Computational complexity
Read section 1.4



No class Monday!
Read section 1.4
Work on Assignment 1
 Due next Friday by 11:59pm


Start on Project 1
Pick teams if you haven't already!