1. What you should already know…. (Appendices C, D, and E)
Review of OOP in Java
What you should already know….
(Appendices C, D, and E)

2. Outline Encapsulation Inheritance Polymorphism
data and operations together in one place
insignificant details hidden
Inheritance
one class a specialized version of another
Polymorphism
allowing arguments based on what they can do, not (necessarily) on what they are

3. Data Structures Course
Learning about useful data structures
Primitive data types
int, double, boolean, char, …
each has operators (+, –, *, /, &&, ||, !, …)
Structured data types
have parts that we can refer to in our programs
Strings (have characters)
Scanners (have sources, delimiters and locales)

4. Structured Data Types in OOP
Structured data encapsulated in classes
data held by an object of this class
Insignificant parts are hidden
don’t really care how the type is implemented
implementation may change with next release
Operations available as methods of class
this is what the object does
consistent from one release to another

5. Classes and Objects Class encapsulates data and operations
keeps them together in one place
String name = "Mark Young"; // data
int len = name.length(); // 10
int space = name.indexOf(" "); // 4 (sic)
String city = "Wolfville"; // more data
String animal = city.substring(0,4); // “Wolf”
Class: String
objects: “Mark Young”, “Wolfville”, “Wolf”
object variables: name, city, animal

6. Classes, Objects and Variables
Class is a kind of thing; a data type
the kind of data and the available operations
Object is an instance of the class; something a variable can refer to
variables refer to, or point to, objects
String variables
String objects
String operations
&
name:
“Mark Young”
get length
find index of
get substring …
&
city:
“Wolfville”
&
animal:
“Wolf”

7. Reference and Co-Reference
Two variables can refer to the same object
Car myCar = new Car(blue); // data
Car disCar = myCar; // same object
Car steves = new Car(blue); // same data
disCar.setColor(green); // myCar is now green
Car variables
Car objects
Car operations
&
myCar: …
get colour
change colour
&
disCar:
&
stevesCar:

8. Data What we know about objects of this class
class says what type it is
object holds information
Class Name: Car
Data:
make: (String)
model: (String)
year: (int)
fuel (l): (double)
mileage (km): (double)
colour: (Color)
Operations: …
&
myCar:
make: Toyota
model: Corolla
year: 2009
fuel (l): 23.7
mileage (km):
colour: RED

9. Operations What we can do with objects of this class
class says what’s available
object carries out actions
Class Name: Car
Data: …
Operations:
get mileage
drive some distance
add fuel
get colour
change colour
make: Toyota
model: Corolla
year: 2009
fuel (l): 23.7
mileage (km):
colour: RED
myCar
make: Toyota
model: Corolla
year: 2009
fuel (l): 17.4
mileage (km):
colour: RED
myCar
myCar, drive 96.3 km.

10. Getters and Setters Methods to get some part of object’s data
getter: getMileage, getFuel, getColor, …
most (non-final) IVs will have getters
Methods to change some part of data
setter: setColor
no setters for final instance variables
no setters for fuel and mileage
but addFuel and drive will change them (“mutaters”)
“immutable” objects have no setters at all!

11. Constructors Put the initial information into the object
use “new” command
give required data
assign to a variable (usu.)
Car myCar = new Car( "Toyota", "Corolla", 2009, Color.RED);
fuel and mileage start at 0.0 /
myCar
&
make: /
model: /
year: 0
fuel (l): 0.0
mileage (km): 0.0
colour: /
make: Toyota
model: Corolla
year: 2009
fuel (l): 0.0
mileage (km): 0.0
colour: RED

12. Constructor Purpose
Make sure every instance variable gets a reasonable value
what the client asks for it to be, if possible
some reasonable default if client doesn’t say
may depend on what else client asks for
Constructor is only place where a final variable can be given a value

13. Inheritance Reuse existing code to create new types
but not copy-and-paste!
New class a specialized version of old class
Car is a specialized Vehicle
Student is a specialized Person
GradStudent is a specialized Student
In Java we say one class extends another
Car extends Vehicle, Student extends Person

14. Composition vs. Inheritance
Don’t confuse inheritance with composition
Composition: “has a”
Person has a Name
Car has a Color
Inheritance: “is a”
Name is not a Person; Person is not a Name
Student is a Person; doesn’t have a Person

15. Polymorphism Subclass is a superclass
so when we need a superclass object…
…a subclass object will do
Need a Person? Use a Student!
public static void greet(Person p) { … }
Person guy = new Person();
Student stu = new Student();
greet(guy); // guy is a Person
greet(stu); // stu is a Person (all Students are)

16. Interfaces Basically a list of method headers Represent a “skill set”
operations something might be able to do
Represent a “skill set”
says “what” but not “how”
Sample interfaces
List<T>: can keep track of a list of T objects
T is any reference type (class or interface)
Comparable<T>: can be compared to T objects
Comparator<T>: can compare T objects

17. Polymorphism Interfaces can be used as data types
public static double roundness(Measurable m) {
return 4 * Math.PI * m.getArea() / Math.pow(m.getPerimeter(), 2); }
any class that implements the interface will do
but it has to say that it implements the interface….
double rc = roundness(new Circle(10.0));
double rr1 = roundness(new Rectangle(10.0, 20.0));
double rr2 = roundness(new Rectangle(0.4, ));
1.0 rc
rr1
rr2

18. GUI as an Example of OOP Encapsulation of a GUI application
javafx.application: Application
Inheritance relations and components
javafx.scene.control
Parent, Pane, StackPane, GridPane, …
Control, Button, Label, TextField, …
Polymorphism and responding to actions
javafx.event: EventHandler<T>

19. Our Goal Program opens up a window like this: What can we do with it?
can enter numbers into the first and second number boxes
can click the “Add” button to put their sum into the result box
can click the “Done” button to end the program

20. Relevant Data Types GUI is an Application In window are Controls
Labels, TextFields and Buttons
Items laid out in a GridPane
rows and columns of controls
Buttons generate Events when clicked
Events handled by EventHandlers

21. Encapsulation: Application
Encapsulates (most) of what a GUI is
Has a Stage (javafx.stage)
the window the GUI is in
may create other stages as it goes along
You set a Scene (javafx.scene) on the stage
contains root object for window’s contents
also contains general event handlers
You subclass this class to create an app

22. Application Methods All operations called by Application.launch
creates the application (calls constructor)
initializes the application (calls init)
starts the application (calls start)
closes the application (calls stop)
main method calls Application.launch
public static void main(String[] args) {
Application.launch(args); }

23. Sub-Typing Application
Create a class that extends Application
public class AdderApplication extends Application
Specify at least the start method
@Override
public void start(Stage primaryStage) { … }
start method can create all the contents
or you can split that between the constructor, init and start

24. Creating an Application
Generally take these steps
create and lay out the controls
create the scene (i.e. attach contents to screen)
add event handlers for scene
set the stage (title, special properties)
show the stage

25. Our Application start Method
@Override public void start(Stage stage) { GridPane root = createControls(); Scene scene = new Scene(root); addAccelerators(scene); stage.setTitle("Adder Window"); stage.setScene(scene); stage.setResizable(false); stage.sizeToScene(); stage.show(); }

26. Inheritance: JavaFX Nodes
Nodes are the visible items in a window
except for Menus and MenuItems
Nodes include Controls and Panes
and several other subtypes as well
Controls are user interface objects
Buttons, TextFields, Labels, and so on
Panes are layout objects
for arranging the controls

27. JavaFX Node Hierarchy (part)
Controls are buttons
and fields and so on
Canvas
MediaView
Group
Control
Parent
Region
A Node containing other Nodes
Node
Pane
Circle
Panes are used
to lay out controls
Line
Rectangle
Shape
Text
Not to be confused with a Label

28. JavaFX Control Hierarchy (part)
MenuBar
TextInputControl
TextField
Control
Label
PasswordField
Labelled
ButtonBase
Button
CheckBox
RadioButton
ToggleButton

29. JavaFX Pane Hierarchy (part)
BorderPane
FlowPane
Pane
GridPane
HBox
StackPane
VBox

30. JavaFX Controls and Panes
Controls are Nodes the user can manipulate
buttons, text fields, labels, choice boxes, …
Panes are used to arrange the Controls inside the window
border layout, grid layout, horizontal and vertical boxes
Create Controls then add them to a Pane
create nested Panes for finer layout

31. Our Controls Labels TextFields Buttons
Label instructions = new Label("Enter numbers:");
specify the text for the label
TextFields
TextField num1Field = new TextField("0");
optionally specify contents of field
Buttons
Button addButton = new Button("Add");
specify label on button

32. Control Methods Can set the font on any of our controls
let’s make a 24 point version of the default font
instructions.setFont(new Font(24));
num1Field.setFont(new Font(24));
addButton.setFont(new Font(24));
Simplify by abstracting into methods:
also create Font constant
private Button makeMyButton(String text) {
Button result = new Button(text);
result.setFont(DEFAULT_FONT);
return result; }

33. More Control Methods Set alignment on text fields
private TextField makeMyField() {
TextField result = new TextField("0");
result.setFont(DEFAULT_FONT);
result.setAlignment(Pos.CENTER_RIGHT);
resturn result; }
Make result field un-editable
TextField resultField = makeMyField();
resultField.setEditable(false);

34. Our Layout A GridPane lays items out in a grid
rows and columns
GridPane root = new GridPane();
Can set properties on the grid
GridPane operations
gaps between rows and columns
root.setHgap(8);
root.setVgap(8);
gap between cells and edges
root.setPadding(new Insets(5));

35. Adding Controls to the Pane
For a GridPane say what and where to add
root.add(resultField, 1, 3);
columns come first
so that’s column 1, row 3
columns and rows numbered from 0
Can spread a control over rows/columns
root.add(instructions, 0, 0, 2, 1);
so that’s 2 columns and 1 row, starting at 0, 0

36. Inactive Window Current window looks OK Doesn’t do anything
has all controls in correct positions
numbers can be typed in
Doesn’t do anything
clicking add/done buttons is useless
can just close the window
Need our buttons to do things

37. Polymorphism: EventHandlers
An EventHandler is an object that can handle events generated by Buttons
and other things as well
EventHandler is a data type, but not a class
it’s an interface
need a class that implements that interface
create it yourself to do what you want
one class per button

38. The EventHandler Interface
Has only one method:
public void handle(Event event);
Done button exits program
use Platform.exit() instead of System.exit(0)
make class private to our application
private class DoneHandler
implements EventHandler<Event> {
@Override
public void handle(Event event) {
Platform.exit(); }

39. Activating a Button Activate by setting onAction property
doneButton.setOnAction(new DoneHandler());
When button is clicked, the new object’s handle method is called
window closes and program ends
Similarly for addButton:
addButton.setOnAction(new AddHandler());
but we’ll come back to that later….

40. Anonymous EventHandlers
Don’t actually need to name the class
just create it where you need it
doneButton.setOnAction(
new EventHandler<Event>() {
@Override
public void handle(Event event) {
Platform.exit(); }
});
specify the interface it implements
implement the method(s)

41. Lambda Expressions Even easier!
setOnAction knows it needs an EventHandler
EventHandler only has one method
so only need parameter and method body
doneButton.setOnAction((Event event) -> {
Platform.exit();
});
and you don't even need to say the parameter type!
doneButton.setOnAction(event -> {

42. Adding the Numbers Read and write from/to TextFields
use getText and Integer.parseInt to read #s
use setText and Integer.toString to show result
addButton.setOnAction(event -> {
int n1, n2, sum;
n1 = Integer.parseInt(num1Field.getText());
n2 = Integer.parseInt(num2Field.getText());
sum = n1 + n2;
resultField.setText(Integer.toString(sum));
});

43. Problem What if non-numbers entered in TextFields?
parseInt can’t change them into numbers
throws a NumberFormatException
Exception is an object that represents an error that has occurred in the program
need to catch that exception and deal with it

44. Dealing with the Exception
Try to add the numbers; catch the exception
addButton.setOnAction(event -> {
try {
int n1, n2, s;
n1=Integer.parseInt(num1Field.getText());
n2=Integer.parseInt(num2Field.getText());
s = n1 + n2;
resultField.setText(Integer.toString(s));
} catch (NumberFormatException nfe) {
resultField.setText("##Error##"); }
});

45. Sample Code Extensions
Sample code also creates tool tips…
words of explanation on hover
Tooltip.install(num1Field, new Tooltip("Enter # here"));
A private method for adding numbers
takes the three fields as its arguments
addButton.setOnAction(event ->
addTheNumbers(num1Field, num2Field, resultField); );

46. Questions

47. Adding Keyboard Accellerators
Press ctrl-f to go to first number field:
scene.getAccelerators().put(
new KeyCodeCombination( KeyCode.F, KeyCombination.SHORTCUT_DOWN),
(Runnable) () -> {
num1Field.requestFocus(); num1Field.selectAll(); });
Requires access to scene and num1Field
make TextFields instance variables
or instance constants  must be done in constructor