Review of Classes
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.
2
Point objects (desired)
Point p1 = new Point(5, -2);
Point p2 = new Point(); // origin, (0, 0)
• Data in each Point object:
Field name Description
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, dy) adjusts the point's x and y by the given amounts
distance(p) how far away the point is from point p
draw(g) displays the point on a drawing panel
3
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)
– The class (blueprint) will describe how to create objects.
– Each object will contain its own data and methods.
• Object is An entity that combines state and behavior.
4
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:
// each Student object has a name and gpa field
// Fields are public by default
public class Student {
String name;
double gpa;
}
5
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
6
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(); x 7 y 2
p2.x = 4;
p2.y = 3;
...
} x 4 y 3
}
7
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];
Point[] points = new Point[3];
index 0 1 2 3 4
words value null null null null null
index 0 1 2
points
value null null null
8
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++) {
words[i] = "word" + i; // phase 2
}
index 0 1 2 3
words
value "word0"
null "word1"
null "word2"
null "word3"
null
9
Arrays of objects (Example)
Point[] points = new Point[3];
points[0] = new Point();
points[2] = new Point();
points[0].x = 10;
index 0 1 2
points
value null null null
x
x ==10
0 x = 0
y = 0
y = 0
setLocation(int, int)
setLocation(int, int) other methods
other methods
10
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;
11
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
index 0 1 2 3 4
Output: value null null null null null
word is: null
Exception in thread "main"
java.lang.NullPointerException
at Example.main(Example.java:8)
12
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();
}
}
index 0 1 2 3 4
words
value "hello"
null
"HELLO" null null
"GOODBYE"
"goodbye" null null
13
Object behavior: Methods
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!");
}
15
Mutator and Acessor methods
// Modify the Object
public void setLocation(int newX, int newY) {
x = newX;
y = newY;
}
public void translate(int dx, int dy) {
x = x + dx;
y = y + dy;
}
// Does not modify the Object
public double distance(Point other) {
int dx = x - other.x;
int dy = y - other.y;
return Math.sqrt(dx * dx + dy * dy);
}
16
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)
17
The toString method
tells Java how to convert an object into a String
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 + ")";
}
18
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.
19
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;
}
...
}
20
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;
}
21
Client code
public class PointMain {
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)
22
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;
}
23
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 Point 24
Encapsulation
• encapsulation: Hiding implementation details from clients.
– Encapsulation forces abstraction.
• separates external view (behavior) from internal view (state)
• protects the integrity of an object's data
25
Private fields
A field that cannot be accessed from outside the class
private type name;
– Examples:
private int id;
private String name;
• Client code won't compile if it accesses private fields:
PointMain.java:11: x has private access in Point
System.out.println(p1.x);
^
26
Accessing private state
// A "read-only" access to the x field ("accessor")
public int getX() {
return x;
}
// Allows clients to change the x field ("mutator")
public void setX(int newX) {
x = newX;
}
– Client code will look more like this:
System.out.println(p1.getX());
p1.setX(14);
27
Updated Point class
// A Point object represents an (x, y) location.
public class Point {
private int x;
private int y;
public Point(int initialX, int initialY) {
x = initialX;
y = initialY;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public double distanceFromOrigin() {
return Math.sqrt(x * x + y * y);
}
public void setLocation(int newX, int newY) {
x = newX;
y = newY;
}
public void translate(int dx, int dy) {
setLocation(x + dx, y + dy);
}
}
28
Benefits of encapsulation
• Abstraction between object and clients
• Protects object from unwanted access
– Example: Can't fraudulently increase an Account's balance.
• Can change the class implementation later
– Example: Point could be rewritten in polar
coordinates (r, θ) with the same methods.
• Can constrain objects' state (invariants)
– Example: Only allow Accounts with non-negative balance.
– Example: Only allow Dates with a month from 1-12. 29
The this keyword
• this : Refers to the implicit parameter inside your class.
(a variable that stores the object on which a method is called)
– Refer to a field: this.field
– Call a method: this.method(parameters);
– One constructor this(parameters);
can call another:
30
Variable shadowing
• shadowing: 2 variables with same name in same scope.
– Normally illegal, except when one variable is a field.
public class Point {
private int x;
private int y;
...
// this is legal
public void setLocation(int x, int y) {
...
}
– In most of the class, x and y refer to the fields.
– In setLocation, x and y refer to the method's parameters.
31
Fixing shadowing
public class Point {
private int x;
private int y;
...
public void setLocation(int x, int y) {
this.x = x;
this.y = y;
}
}
• Inside setLocation,
– To refer to the data field x, say this.x
– To refer to the parameter x, say x
32
Calling another constructor
public class Point {
private int x;
private int y;
public Point() {
this(0, 0); // calls (x, y) constructor
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
...
}
• Avoids redundancy between constructors
• Only a constructor (not a method) can call another constructor
33
Classes as modules
• module: A reusable piece of software, stored as a class.
– Example module classes: Math, Arrays, System
// This class is a module that contains useful methods
// related to factors and prime numbers.
public class Factors {
// Returns the number of factors of the given integer.
public static int countFactors(int number) {
int count = 0;
for (int i = 1; i <= number; i++) {
if (number % i == 0) {
count++; // i is a factor of the number
}
}
return count;
}
// Returns true if the given number is prime.
public static boolean isPrime(int number) {
return countFactors(number) == 2;
}
} 34
More about modules
• A module is a partial program, not a complete program.
– It does not have a main. You don't run it directly.
– Modules are meant to be utilized by other client classes.
• Syntax:
class.method(parameters);
• Example:
int factorsOf24 = Factors.countFactors(24);
35
Using a module
// This program sees whether some interesting numbers are prime.
public class Primes {
public static void main(String[] args) {
int[] nums = {1234517, 859501, 53, 142};
for (int i = 0; i < nums.length; i++) {
if (Factors.isPrime(nums[i])) {
System.out.println(nums[i] + " is prime");
}
}
}
}
// This program prints all prime numbers up to a given maximum.
public class Primes2 {
public static void main(String[] args) {
Scanner console = new Scanner(System.in);
System.out.print("Max number? ");
int max = console.nextInt();
for (int i = 2; i <= max; i++) {
if (Factors.isPrime(i)) {
System.out.print(i + " ");
} }
System.out.println();
}
}
36
Modules in Java libraries
// Java's built in Math class is a module
public class Math {
public static final double PI = 3.14159265358979323846;
...
public static int abs(int a) {
if (a >= 0) {
return a;
} else {
return -a;
}
}
public static double toDegrees(double radians) {
return radians * 180 / PI;
}
}
37
Static fields
private static type name;
or,
private static type name = value;
– Example: private static int theAnswer = 42;
• static field: Stored in the class instead of each object.
– A "shared" global field that all objects can access and modify.
– Like a class constant, except that its value can be changed.
• Accessing static field from inside the class where the field was declared:
fieldName // get the value
fieldName = value; // set the value
• Accessing static field from another class (if the field is public):
ClassName.fieldName // get the value
ClassName.fieldName = value; // set the value
• generally static fields are not public unless they are final
38
BankAccount
public class BankAccount {
// static count of how many accounts are created
// (only one count shared for the whole class)
private static int objectCount = 0;
// fields (replicated for each object)
private String name;
private int id;
public BankAccount() {
objectCount++; // advance the id, and
id = objectCount; // give number to account
}
...
public int getID() { // return this account's id
return id;
}
}
39
Static methods
// the same syntax you've already used for methods
public static type name(parameters) {
statements;
}
• static method: Stored in a class, not in an object.
– Shared by all objects of the class, not replicated.
– Does not have any implicit parameter, this;
therefore, cannot access any particular object's fields.
40
BankAccount solution
public class BankAccount {
// static count of how many accounts are created
// (only one count shared for the whole class)
private static int objectCount = 0;
// clients can call this to find out # accounts created
public static int getNumAccounts() {
return objectCount;
}
// fields (replicated for each object)
private String name;
private int id;
public BankAccount() {
objectCount++; // advance the id, and
id = objectCount; // give number to account
}
...
public int getID() { // return this account's id
return id;
}
}
41
Summary of Java classes
• A class is used for any of the following in a large program:
– a program : Has a main and perhaps other static methods.
– an object class : Defines a new type of objects.
• example: Point, BankAccount
• declares object fields, constructor(s), and methods
• might declare static fields or methods, but these are less of a focus
• should be encapsulated (all fields and static fields private)
– a module : Utility code implemented as static methods.
• example: Math
42
