Building Java Programs

Chapter 8
Classes

Copyright (c) Pearson 2020.

All rights reserved.
 A programming problem
• Given a file of cities' (x, y) coordinates,
which begins with the number of cities:
6
50 20
90 60
10 72
74 98
5 136
150 91

• Write a program to draw the cities on a DrawingPanel, then

drop a "bomb" that turns all cities red that are within a given
radius:
Blast site x? 100
Blast site y? 100
Blast radius? 75
Kaboom! 2
 A bad solution
Scanner170 input = new Scanner170(new
File("cities.txt"));
int cityCount = input.nextInt();
int[] xCoords = new int[cityCount];
int[] yCoords = new int[cityCount];
for (int i = 0; i < cityCount; i++) {
xCoords[i] = input.nextInt(); // read each city
yCoords[i] = input.nextInt();
}
...

– parallel arrays: 2+ arrays with related data at same indexes.

• Considered poor style.

3
 Observations
• The data in this problem is a set of points.
• It would be better stored as Point objects.
– A Point would store a city's x/y data.

– We could compare distances between Points

to see whether the bomb hit a given city.

– Each Point would know how to draw itself.

– The overall program would be shorter and cleaner.

4
 Clients of objects
• client program: A program that uses objects.
– Example: Bomb is a client of DrawingPanel and Graphics.

DrawingPanel.java (class)
Bomb.java (client program)
public class DrawingPanel {
public class Bomb {
...
main(String[] args) {
}
new DrawingPanel(...)
new DrawingPanel(...)
...
}
}

5
 Classes and objects
• class: A program entity that represents either:
1. A program / module, or
2. A template for a new type of objects.

– The DrawingPanel class is a template for creating

DrawingPanel objects.

• object: An entity that combines state and behavior.

– object-oriented programming (OOP): Programs that
perform their behavior as interactions between objects.

6
 Blueprint analogy
iPod blueprint
state:
current song
volume
battery life
behavior:
power on/off
change station/song
change volume
choose random song

create
s
iPod #1 iPod #2 iPod #3
state: state: state:
song = "1,000,000 song = "Letting You" song = "Discipline"
Miles" volume = 9 volume = 24
volume = 17 battery life = 3.41 battery life = 1.8
battery life = 2.5 hrs hrs
hrs behavior: behavior:
behavior: power on/off power on/off
power on/off change station/song change station/song
change station/song change volume change volume
change volume choose random choose random
choose random song song 7
song
 Abstraction
• abstraction: A distancing between ideas and details.
– We can use objects without knowing how they work.

• abstraction in an iPod:
– You understand its external behavior (buttons, screen).
– You don't understand its inner details, and you don't need
to.

8
 Our task
• In the following slides, we will implement a Point class
as a way of learning about defining classes.

– We will define a type of objects named Point.

– Each Point object will contain x/y data called fields.
– Each Point object will contain behavior called methods.
– Client programs will use the Point objects.

9
 Point objects (desired)
Point p1 = new Point(5, -2);
Point p2 = new Point(); // origin, (0, 0)

• Data in each Point object:

Field Description
name
x the point's x-coordinate
y the point's y-coordinate

• Methods in each Point object:

Method name Description
setLocation(x, y) sets the point's x and y to the given values
translate(dx, adjusts the point's x and y by the given amounts
dy)
distance(p) how far away the point is from point p
draw(g) displays the point on a drawing panel 10
 Point class as blueprint
Point class
state:
int x, y
behavior:
setLocation(int x, int y)
translate(int dx, int dy)
distance(Point p)
draw(Graphics g)

Point object #1 Point object #2 Point object #3

state: state: state:
x = 5, y = -2 x = -245, y = 1897 x = 18, y = 42
behavior: behavior: behavior:
setLocation(int x, int y) setLocation(int x, int y) setLocation(int x, int y)
translate(int dx, int dy) translate(int dx, int dy) translate(int dx, int dy)
distance(Point p) distance(Point p) distance(Point p)
draw(Graphics g) draw(Graphics g) draw(Graphics g)

– The class (blueprint) will describe how to create objects.

– Each object will contain its own data and methods.
11
Object state: Fields
 Point class, version 1
public class Point {
int x;
int y;
}
– Save this code into a file named Point.java.

• The above code creates a new type named Point.

– Each Point object contains two pieces of data:
• an int named x, and
• an int named y.

– Point objects do not contain any behavior (yet).

13
 Fields
• field: A variable inside an object that is part of its
state.
– Each object has its own copy of each field.

• Declaration syntax:
type name;

– Example:
public class Student {
String name; // each Student object has a
double gpa; // name and gpa field
}

14
 Accessing fields
• Other classes can access/modify an object's fields.
– access: variable.field
– modify: variable.field = value;

• Example:
Point p1 = new Point();
Point p2 = new Point();
System.out.println("the x-coord is " + p1.x); // access
p2.y = 13; // modify

15
 A class and its client
• Point.java is not, by itself, a runnable program.
– A class can be used by client programs.

Point.java (class of objects)

PointMain.java (client program) public class Point {
public class PointMain { int x;
main(String args) { int y;
Point p1 = new Point(); }
p1.x = 7;
p1.y = 2;

Point p2 = new Point();

p2.x = 4;
x 7 y 2
p2.y = 3;
...
}
} x 4 y 3

16
 PointMain client example
public class PointMain {
public static void main(String[] args) {
// create two Point objects
Point p1 = new Point();
p1.y = 2;
Point p2 = new Point();
p2.x = 4;
System.out.println(p1.x + ", " + p1.y); // 0, 2
// move p2 and then print it
p2.x += 2;
p2.y++;
System.out.println(p2.x + ", " + p2.y); // 6, 1
}
}

• Exercise: Modify the Bomb program to use Point objects.

17
 Arrays of objects
• null : A value that does not refer to any object.
– The elements of an array of objects are initialized to null.
String[] words = new String[5];
DrawingPanel[] windows = new DrawingPanel[3];

inde 0 1 2 3 4
words x
valu nul nul nul nul nul
e l l l l l
inde 0 1 2
windows x
valu nul nul nul
e l l l

18
 Things you can do w/
null
• store null in a variable or an array element
String s = null;
words[2] = null;

• print a null reference

System.out.println(s); // null

• ask whether a variable or array element is null

if (words[2] == null) { ...

• pass null as a parameter to a method

System.out.println(null); // null

• return null from a method (often to indicate failure)

return null;
19
 Null pointer exception
• dereference: To access data or methods of an object
with the dot notation, such as s.length() .
– It is illegal to dereference null (causes an exception).
– null is not any object, so it has no methods or data.

String[] words = new String[5];

System.out.println("word is: " + words[0]);
words[0] = words[0].toUpperCase(); // ERROR

inde 0 1 2 3 4
Output: x
word is: null valu nul nul nul nul nul
Exception in thread "main" e l l l l l
java.lang.NullPointerException
at Example.main(Example.java:8)
20
 Looking before you leap
• You can check for null before calling an object's
methods.
String[] words = new String[5];
words[0] = "hello";
words[2] = "goodbye"; // words[1], [3], [4] are null

for (int i = 0; i < words.length; i++) {

if (words[i] != null) {
words[i] = words[i].toUpperCase();
}
}
inde 0 1 2 3 4
words x
valu "HELLO" nul "GOODBYE" nul nul
e l l l
21
 Two-phase initialization
1) initialize the array itself (each element is initially null)
2) initialize each element of the array to be a new object

String[] words = new String[4]; // phase 1

for (int i = 0; i < words.length; i++) {
coords[i] = "word" + i; // phase 2
}

inde 0 1 2 3
words x
valu "word0" "word1" "word2" "word3"
e

22
 Bomb answer 1
import java.awt.*;
import java.io.*;
// import java.util.*; // not needed because using Scanner170
// Displays a set of cities and simulates dropping a "bomb" on them.
public class Bomb {
public static void main(String[] args) throws FileNotFoundException {
DrawingPanel panel = new DrawingPanel(200, 200);
Graphics g = panel.getGraphics();
Scanner170 input = new Scanner170(new File("cities.txt"));
Point[] cities = readCities(input, g);
// drop the "bomb"
Scanner170 console = new Scanner170(System.in);
Point bomb = new Point();
System.out.print("Blast site x? ");
bomb.x = console.nextInt();
System.out.print("Blast site y? ");
bomb.y = console.nextInt();
System.out.print("Blast radius? ");
int radius = console.nextInt();
boom(bomb, radius, cities, g);
}
...

23
 Bomb answer 2
// Reads input file of cities and returns them as array of Points.
public static Point[] readCities(Scanner170 input, Graphics g) {
int numCities = input.nextInt(); // first line = # of cities
Point[] cities = new Point[numCities];
for (int i = 0; i < cities.length; i++) {
cities[i] = new Point();
cities[i].x = input.nextInt(); // read city x/y from file
cities[i].y = input.nextInt();
g.fillOval(cities[i].x, cities[i].y, 3, 3);
g.drawString("(" + cities[i].x + ", " + cities[i].y + ")",
cities[i].x, cities[i].y);
}
return cities;
}
// Simulates dropping a bomb at the given location on the given cities.
public static void boom(Point bomb, int radius, Point[] cities, Graphics g) {
g.setColor(Color.RED);
g.drawOval(bomb.x - radius, bomb.y - radius, 2 * radius, 2 * radius);
for (int i = 0; i < cities.length; i++) {
int dx = cities[i].x - bomb.x;
int dy = cities[i].y - bomb.y;
double distance = Math.sqrt(dx * dx + dy * dy);
if (distance <= radius) {
g.fillOval(cities[i].x, cities[i].y, 3, 3);
g.drawString("(" + cities[i].x + ", " + cities[i].y + ")",
cities[i].x, cities[i].y);
}
}
System.out.println("Kaboom!");
}
}

24
Object behavior:
Methods
 Client code redundancy
• Our client program wants to draw Point objects:
// draw each city
g.fillOval(cities[i].x, cities[i].y, 3, 3);
g.drawString("(" + cities[i].x + ", " + cities[i].y + ")",
cities[i].x, cities[i].y);

• To draw them in other places, the code must be

repeated.
– We can remove this redundancy using a method.

26
 Eliminating redundancy,
v1
• We can eliminate the redundancy with a static method:
// Draws the given point on the DrawingPanel.
public static void draw(Point p, Graphics g) {
g.fillOval(p.x, p.y, 3, 3);
g.drawString("(" + p.x + ", " + p.y + ")", p.x, p.y);
}

• main would call the method as follows:

// draw each city
draw(cities[i], g);

27
 Problem with static
method
• We are missing a major benefit of objects: code reuse.
– Every program that draws Points would need a draw
method.

• The syntax doesn't match how we're used to using

objects.
draw(cities[i], g); // static (bad)

• The point of classes is to combine state and behavior.

– The draw behavior is closely related to a Point's data.
– The method belongs inside each Point object.
28
 Instance methods
• instance method (or object method): Exists inside
each object of a class and gives behavior to each
object.

public type name(parameters) {

statements;
}
– same syntax as static methods, but without static
keyword

Example:
public void shout() {
System.out.println("HELLO THERE!"); 29
 Instance method
example
public class Point {
int x;
int y;
// Draws this Point object with the given pen.
public void draw(Graphics g) {
...
}
}
– The draw method no longer has a Point p parameter.
– How will the method know which point to draw?
• How will the method access that point's x/y data?

30
 Point objects w/ method
• Each Point object has its own copy of the draw method,
which operates on that object's state:
p1
Point p1 = new Point();
p1.x = 7;
p1.y = 2;
x 7 y 2
Point p2 = new Point();
public void draw(Graphics g) {
p2.x = 4; // this code can see p1's x
p2.y = 3; and y
}
p1.draw(g);
p2.draw(g); x 4 y 3
p2
public void draw(Graphics g) {
// this code can see p2's x
and y
}
31
 The implicit parameter
• implicit parameter:
The object on which an instance method is called.
– During the call p1.draw(g);
the object referred to by p1 is the implicit parameter.

– During the call p2.draw(g);

the object referred to by p2 is the implicit parameter.

– The instance method can refer to that object's fields.

• We say that it executes in the context of a particular object.
• draw can refer to the x and y of the object it was called on.

32
 Point class, version 2
public class Point {
int x;
int y;
// Changes the location of this Point object.
public void draw(Graphics g) {
g.fillOval(x, y, 3, 3);
g.drawString("(" + x + ", " + y + ")", x, y);
}
}

– Each Point object contains a draw method that draws

that point at its current x/y position.

33
 Kinds of methods
• accessor: A method that lets clients examine object
state.
– Examples: distance, distanceFromOrigin
– often has a non-void return type

• mutator: A method that modifies an object's state.

– Examples: setLocation, translate

34
 Mutator method
questions
• Write a method setLocation that changes a Point's
location to the (x, y) values passed.

• Write a method translate that changes a Point's

location by a given dx, dy amount.

– Modify the Point and client code to use these methods.

35
 Mutator method answers
public void setLocation(int newX, int newY) {
x = newX;
y = newY;
}

public void translate(int dx, int dy) {

x = x + dx;
y = y + dy;
}

// alternative solution that utilizes setLocation

public void translate(int dx, int dy) {
setLocation(x + dx, y + dy);
}

36
 Accessor method
questions
• Write a method distance that computes the distance
between a Point and another Point parameter.

Use the formula: x2  x1 2  y2  y1 

2

• Write a method distanceFromOrigin that returns the

distance between a Point and the origin, (0, 0).

– Modify the client code to use these methods.

37
 Accessor method
answers
public double distance(Point other) {
int dx = x - other.x;
int dy = y - other.y;
return Math.sqrt(dx * dx + dy * dy);
}

public double distanceFromOrigin() {

return Math.sqrt(x * x + y * y);
}

// alternative solution that uses distance

public double distanceFromOrigin() {
Point origin = new Point();
return distance(origin);
}

38
 Printing objects
• By default, Java doesn't know how to print objects:
Point p = new Point();
p.x = 10;
p.y = 7;
System.out.println("p is " + p); // p is Point@9e8c34

// better, but cumbersome; p is (10, 7)

System.out.println("p is (" + p.x + ", " + p.y + ")");

// desired behavior
System.out.println("p is " + p); // p is (10, 7)

39
 The toString method
tells Java how to convert an object into a String

Point p1 = new Point(7, 2);

System.out.println("p1: " + p1);

// the above code is really calling the following:

System.out.println("p1: " + p1.toString());

• Every class has a toString, even if it isn't in your code.

– Default: class's name @ object's memory address (base 16)

Point@9e8c34

40
 toString syntax
public String toString() {
code that returns a String representing this
object;
}

– Method name, return, and parameters must match

exactly.

– Example:
// Returns a String representing this Point.
public String toString() {
return "(" + x + ", " + y + ")";
}

41
Object initialization:
constructors
 Initializing objects
• Currently it takes 3 lines to create a Point and initialize
it:
Point p = new Point();
p.x = 3;
p.y = 8; // tedious

• We'd rather specify the fields' initial values at the start:

Point p = new Point(3, 8); // better!

– We are able to this with most types of objects in Java.

43
 Constructors
• constructor: Initializes the state of new objects.

public type(parameters) {
statements;
}

– runs when the client uses the new keyword

– no return type is specified;
it implicitly "returns" the new object being created

– If a class has no constructor, Java gives it a default

constructor with no parameters that sets all fields to 0.
44
 Constructor example
public class Point {
int x;
int y;

// Constructs a Point at the given x/y location.

public Point(int initialX, int initialY) {
x = initialX;
y = initialY;
}

public void translate(int dx, int dy) {

x = x + dx;
y = y + dy;
}

...
}

45
 Tracing a constructor call
• What happens when the following call is made?
Point p1 = new Point(7, 2);

p1 x y

public Point(int initialX, int initialY)

{
x = initialX;
y = initialY;
}

public void translate(int dx, int dy) {

x += dx;
y += dy;
}
46
 Client code, version 3
public class PointMain3 {
public static void main(String[] args) {
// create two Point objects
Point p1 = new Point(5, 2);
Point p2 = new Point(4, 3);
// print each point
System.out.println("p1: (" + p1.x + ", " + p1.y + ")");
System.out.println("p2: (" + p2.x + ", " + p2.y + ")");
// move p2 and then print it again
p2.translate(2, 4);
System.out.println("p2: (" + p2.x + ", " + p2.y + ")");
}
}
OUTPUT:
p1: (5, 2)
p2: (4, 3)
p2: (6, 7)

47
 Multiple constructors
• A class can have multiple constructors.
– Each one must accept a unique set of parameters.

• Exercise: Write a Point constructor with no parameters

that initializes the point to (0, 0).

// Constructs a new point at (0, 0).

public Point() {
x = 0;
y = 0;
}

48
 Common constructor
bugs
1. Re-declaring fields as local variables ("shadowing"):
public Point(int initialX, int initialY) {
int x = initialX;
int y = initialY;
}
– This declares local variables with the same name as the
fields, rather than storing values into the fields. The
fields remain 0.

2. Accidentally giving the constructor a return type:

public void Point(int initialX, int initialY) {
x = initialX;
y = initialY;
}
– This is actually not a constructor, but a method named
49