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 (); } 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 Summer extends Thread { private double[] array; private int start; private int end; private 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 class Summer extends Thread { private double[] array; private int start; private int end; private 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; } 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 Code and data together Work divided into functions Code separated, but data shared Objects Code and data separated

 A template or prototype for an object Class: Human Object: David Bowie Object: Barack Obama Class: Company Object: Microsoft 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; } 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++; } } 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 //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"); } 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 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 Stuff { private int things; public void setThings(int things) { this.things = things; }

public class SelfAdder { publicvoid addToList(List list) { list.add(this); } public class SelfAdder { publicvoid 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 } 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 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!" ); } 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 ); } 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 )  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 { 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 Pair { 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 pair1 = new Pair ("ham", "eggs"); Pair pair2 = new Pair ( 5, 7 ); pair1.swap(); System.out.println( pair1 ); System.out.println( pair2 ); } public class Test { public static void main(String[] args) { Pair pair1 = new Pair ("ham", "eggs"); Pair pair2 = new Pair ( 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

 Work on Assignment 1  Due next Friday by 11:59pm  Start on Project 1