Download Quiz About [Your topic]

Using Objects
Chapter 3
Fall 2005
CS 101
Aaron Bloomfield
1
Getting classy
 Purpose of this chapter
 Gain experience creating and manipulating objects from
the standard Java types
 Why
 Prepares you for defining your own classes and creating
and manipulating the objects of those classes
2
Values versus objects
 Numbers
 Have values but they do not have behaviors
 Objects
 Have attributes and behaviors
 System.in
 References an InputStream
 Attribute: keyboard
 Behaviors: reading
 System.out
 References an OutputStream
 Attribute: monitor
 Behaviors: printing
3
Using objects
 First, we create an object:
 Scanner stdin = new Scanner (System.in);
 Most object creation lines look like this
 Then we use the object
 stdin.nextInt();
 stdin.nextDouble();
 Note that we could have called the object foo, bar, or
anything
 stdin is just what we chose to call it
4
Using Rectangle objects
 Let’s create some Rectangle objects
 Rectangle creation:
 Rectangle r = new Rectangle (10, 20);
 Objects have attributes (or properties):
 System.out.println (r.length);
 System.out.println (r.width);
 Objects have behaviors (or methods):
 r.grow (10, 20)
 r.isEmpty()
 r.setLocation (5,4)
5
Using String objects
 Let’s create some String objects
 String creation:
 String s = new String (“Hello world”);
 Objects have attributes (or properties):
 But we can’t access them…
 Objects have behaviors (or methods):
 s.substring(0,6)
 s.indexOf (“world”)
 s.toLowerCase()
6
The lowdown on objects
 Objects are “things” that have properties (attributes) and
behaviors (methods)
 We first create one or more objects
 We then manipulate their properties and call their methods
7
So why bother with objects?
 Let’s say you want to do a lot of String manipulation
 Once you create a String object, all the manipulation
methods are contained therein
 Sun already wrote the methods for us
 So we can use String objects instead of writing our own code
to get the substring, indexOf, etc.
8
More on Strings
 Strings are used very often
 As a shortcut, you can use:
 String s = “Hello world”;
instead of:
 String s = new String (“Hello world”);
 It’s just a shortcut that Java allows
 The two lines are almost the same
 There is a minor difference between the two
 Which we’ll get to later
9
Visualizing objects

Class (type) name
- width = 10
- height = 20
- ...

Attributes (properties)
+ grow (int, int) : void
+ isEmpty ( ) : void
+ setLocation ( int, int ) : void
+ resize ( int, int ) : void
+ ...

Methods (behaviors)
Rectangle
10
Date translation
 Goal: to translate the date from American format to standard
format
11
How well do we understand using
objects?
13
Sidewalk chalk guy

Source:
http://www.gprime.net/images/sidewalkchalkguy/
14
Java and variables
 Consider:
int x = 7;
double d;
char c = ‘x’;
int x
double d
char c
7
-
‘x’
 The variable name is the actual spot in memory where the
value is stored
15
What is a reference
 A reference is a memory address
 References are like pointers in C/C++
 But they are not the exact same thing!
 C++ has references also (in addition to pointers)
 You may hear me call them pointers instead of references
 All objects in Java are declared as references
16
References 1
 Consider:
int j = 5;
String s = “Hello world”;
Note that there is
no “new” here
 Java translates that last line into:
String s = new String (“Hello world”);
(Not really, but close enough for this lecture)
17
References 2

What’s happening in memory
int j = 5;
String s = “Hello world”;
String s
0x0d4fe1a8
Takes up 32 bits
(4 bytes) of memory
Takes up 32 bits
(4 bytes) of memory
int j
5
At memory location
0x0d4fe1a8
Takes up 12
bytes of memory

Hello world
Primitive types are never references; only objects
18
Other Java object types
 String
 Rectangle
 Color
 JFrame
19
Representation
 Statements
int peasPerPod = 8;
String message = "Don't look behind the door!“
message
peasPerPod
String
- text = "Don't look behind the door!"
- length = 27
- ...
+ length () : int
+ charAt ( int i ) : char
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ ...
20
Representation
String s = “I love CS 101”;
int l = s.length();
char c = s.charAt (3);
String t = s.subString(1,2);
int t = s.indexOf (t, 0);
s
String
- text = “I love CS 101"
- length = 13
- ...
+ length () : int
+ charAt ( int i ) : char
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ ...
21
Shorthand representation
 Statements
int peasPerPod = 8;
String message = "Don't look behind the door!“
peasPerPod
message
8
"Don't look behind the door!"
22
Examples
 Consider
String a = "excellence“;
String b = a;
 What is the representation?
a
"excellence"
b
23
Uninitialized versus null
 Consider
String dayOfWeek;
Scanner inStream;
 What is the representation?
dayOfWeek
-
inStream
-
24
Uninitialized versus null
 Consider
String fontName = null;
Scanner fileStream = null;
 What is the representation?
fontName
null
fileStream
null
OR
fontName
fileStream
25
The null reference
 Sometimes you want a reference to point to nothing
 Use the null reference:
String s = null;
 The null reference is equivalent to a memory address of zero
(0x00000000)
 No user program can exist there
26
The null reference
 Consider:
String s = “Hello world”;
System.out.println (s.length());
 What happens?
 Java prints
out 11
s
String
- text = “Hello world"
- length = 11
- ...
+ length () : int
+ charAt ( int i ) : char
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ ...
27
Computer bugs
28
The null reference
 Consider:
String s = null;
System.out.println (s.length());
 This is called accessing (or following) a null pointer/reference
 What happens?
 Java: java.lang.NullPointerException
 C/C++: Segmentation fault (core dumped)
 Windows: …
29
So what is a null reference good for?
 Let’s say you had a method that returned a String when
passed some parameters
 Normally it returns a valid String
 But what if it can’t? How to deal with that?
 Return a null reference
30
References and memory
 Most modern computers are 32-bit computers
 This means that a reference takes up 32 bits
 232 = 4 Gb
 This means that a 32-bit machine cannot access more
than 4 Gb of memory!
 Well, without doing some “tricks”, at least
 Most machines come with 1 Gb memory these days
 Will come with 4 Gb in a year or so
 64-bit machines will have a maximum of 16 exabytes of
memory
 Giga, Tera, Peta, Exa
 That’s 16 billion Gb!
31
References 4

Consider:
String s1 = “first string”;
String s2 = “second string”;
s2 = s1;
System.out.println (s2);
What happens
to this?
String s1
“first string”
“second string”
String s2
length = 12
length = 13
32
Java’s garbage collection
 If an object in memory does not have a reference pointing to
it, Java will automagically delete the object
 This is really cool!
 In C/C++, you had to do this by yourself
33
Assignment
 Consider
String word1 = "luminous";
String word2 = "graceful";
word1 = word2;
Garbage
collection
time!
 Initial representation
word1
"luminous"
word2
"graceful"
34
Using objects
 Consider
Scanner stdin = new Scanner(System.in);
System.out.print("Enter your account name: ");
String response = stdin.next();
 Suppose the user interaction is
Enter your account name: artiste
reponse
stdin
"artiste"
Scanner:
35
String representation
 Consider
 String alphabet = "abcdefghijklmnopqrstuvwxyz";
 Standard shorthand representation
alphabet
"abcdefghijklmnopqrstuvwxyz"
 Truer representation
alphabet
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
y
36
z
String representation
 Consider
 String alphabet = "abcdefghijklmnopqrstuvwxyz";
 char c1 = alphabet.charAt(9);
 char c2 = alphabet.charAt(15);
 char c3 = alphabet.charAt(2);
 What are the values of c1, c2, and c3? Why?
c1
'j'
c2
'p'
c3
'c'
37
Program WordLength.java
public class WordLength {
public static void main(String[] args) {
Scanner stdin = new Scanner(System.in);
System.out.print("Enter a word: ");
String word = stdin.next();
int wordLength = word.length();
System.out.println("Word " + word + " has length "
+ wordLength + ".");
}
}
38
Program demo
39
An optical illusion
40
More String methods
 Consider
String weddingDate = "August 21, 1976";
String month = weddingDate.substring(0, 6);
System.out.println("Month is " + month + ".");
 What is the output?
Month is August.
41
More String methods
 Consider
String fruit = "banana";
String searchString = "an";
int n1 = fruit.indexOf(searchString, 0);
int n2 = fruit.indexOf(searchString, n1 + 1);
int n3 = fruit.indexOf(searchString, n2 + 1);
System.out.println("First search: " + n1);
System.out.println("Second search: " + n2);
System.out.println("Third search: " + n3);
 What is the output?
First search: 1
Second search: 3
Third search: -1
42
Review
 Variables of primitive types
 int, double, char, boolean, etc.
 Can assign a value to it
 Can read a value from it
 Can’t do much else!
 Objects
 String, Rectangle, etc.
 Have many parts
 Rectangle has width, length, etc.
 Like a complex type
 Have methods
 String has length(), substring(), etc.
44
Variable declaration
 Consider:
 int x = 5;
 int x = 7;
 Java won’t allow this
 You can only declare a variable once
 At the int x=7; line, Java already has a x spot in memory
 It can’t have two
45
String methods
 length(): returns the String’s length (duh!)
String s = “hello world”;
String t = “goodbye”;
System.out.println (s.length());
System.out.println (t.length());
 Prints 11 and 7
 Note that calling s.length() is different than calling t.length()!
 Both return the length
 But of different Strings
46
More String methods
 Consider
String weddingDate = "August 21, 1976";
String month = weddingDate.substring(0, 6);
System.out.println("Month is " + month + ".");
 What is the output?
Month is August.
47
More String methods
 Consider
String fruit = "banana";
String searchString = "an";
int n1 = fruit.indexOf(searchString, 0);
int n2 = fruit.indexOf(searchString, n1 + 1);
int n3 = fruit.indexOf(searchString, n2 + 1);
System.out.println("First search: " + n1);
System.out.println("Second search: " + n2);
System.out.println("Third search: " + n3);
 What is the output?
First search: 1
Second search: 3
Third search: -1
48
Program WordLength.java
public class WordLength {
public static void main(String[] args) {
Scanner stdin = new Scanner(System.in);
System.out.print("Enter a word: ");
String word = stdin.next();
int wordLength = word.length();
System.out.println("Word " + word + " has length "
+ wordLength + ".");
}
}
49
Program demo
50
PhoneNumberFun.java
import java.util.*;
public class PhoneNumberFun {
// main(): demonstrates a simple String manipulation
public static void main(String[] args) {
//...
// determine the area code
// determine the local number
// arrange result
// display input and result
}
}
51
Program demo
52
Lots of piercings…
This may be a bit disturbing…
53
More String methods
 trim()
 Returns the String without leading and trailing whitespace
 Whitespace is a space, tab, or return
54
DateTranslation.java
// Convert user-specified date from American to standard format
import java.util.*;
class DateTranslation {
// main(): application entry point
static public void main(String args[]) {
// produce a legend (Step 1)
// prompt the user for a date in American format (Step 2)
// acquire the input entered by the user (Step 3)
// echo the input back (Step 4)
// get month entered by the user (Step 5)
// get day entered by the user (Step 6)
// get year entered by the user (Step 7)
// create standard format version of input (Step 8)
// display the translation (Step 9)
}
}
55
Program demo
56
Variables vs. Types

The type is the recipe or template for how to create a variable
 Examples: int, double, char, boolean, etc.
 There are only 8 primitive types
 There are only a few things you can do with a type:
 Declare a variable
 int x;
 Use it as a cast
 x = (int) 3.5;
 There is only one of each type

The variable is the actual instance of a type in memory
 It’s a spot in memory where you store a value
 You choose the name: width, x, thatThemThereValue, etc.
 You can have as may variables as you want – but only one type!

Like the difference between a recipe and a bunch of cookies
57
How well do we understand variables
versus types?
58
Classes vs. Objects
 A class is a user-defined “thing”
 Examples: String, Scanner, Rectangle, etc.
 We’ll start defining our own classes next chapter
 Classes are more complex than the primitive types
 A class is analogous to a type
 It’s just more complex and user-defined
 There can be only one class of each name
 An object is an instance of a class
 There is only one String class, but you can have 100
String objects
 A object is analogous to a variable
 It just is a reference instead
 A class is a “template” used for creating objects
59
More on classes vs. objects
60
How well do we understand classes
versus objects?
61
The 2004 Ig Nobel Prizes







Medicine
Physics
Public Health
Chemistry
Engineering
Literature
Psychology

Economics
Peace

Biology

"The Effect of Country Music on Suicide.“
For explaining the dynamics of hula-hooping
Investigating the scientific validity of the FiveSecond Rule
The Coca-Cola Company of Great Britain
For the patent of the combover
The American Nudist Research Library
It’s easy to overlook things – even a man in a
gorilla suit.
The Vatican, for outsourcing prayers to India
The invention of karaoke, thereby providing an
entirely new way for people to learn to tolerate
each other
For showing that herrings apparently communicate
62
by farting
References
63
Java and variables
 Consider:
int x = 7;
double d;
char c = ‘x’;
int x
double d
char c
7
-
‘x’
 The variable name is the actual spot in memory where the
value is stored
64
What is a reference
 A reference is a memory address
 References are like pointers in C/C++
 But they are not the exact same thing!
 C++ has references also (in addition to pointers)
 You may hear me call them pointers instead of references
 All objects in Java are declared as references
65
References 1
 Consider:
int j = 5;
String s = “Hello world”;
Note that there is
no “new” here
 Java translates that last line into:
String s = new String (“Hello world”);
(Not really, but close enough for this lecture)
66
References 2

What’s happening in memory
int j = 5;
String s = “Hello world”;
String s
0x0d4fe1a8
Takes up 32 bits
(4 bytes) of memory
Takes up 32 bits
(4 bytes) of memory
int j
5
At memory location
0x0d4fe1a8
Takes up 12
bytes of memory

Hello world
Primitive types are never references; only objects
67
Representation
 Statements
int peasPerPod = 8;
String message = "Don't look behind the door!“
message
peasPerPod
String
- text = "Don't look behind the door!"
- length = 27
- ...
+ length () : int
+ charAt ( int i ) : char
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ ...
68
Representation
String s = “I love CS 101”;
int l = s.length();
char c = s.charAt (3);
String t = s.subString(1,2);
int t = s.indexOf (t, 0);
s
String
- text = “I love CS 101"
- length = 13
- ...
+ length () : int
+ charAt ( int i ) : char
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ ...
69
Shorthand representation
 Statements
int peasPerPod = 8;
String message = "Don't look behind the door!“
peasPerPod
message
8
"Don't look behind the door!"
70
Examples
 Consider
String a = "excellence“;
String b = a;
 What is the representation?
a
"excellence"
b
71
References 3

Consider:
String s1 = “first string”;
String s2 = “second string”;
s2 = s1;
System.out.println (s2);
What happens
to this?
String s1
“first string”
“second string”
String s2
length = 12
length = 13
72
Java’s garbage collection
 If an object in memory does not have a reference pointing to
it, Java will automagically delete the object
 This is really cool!
 In C/C++, you had to do this by yourself
73
Warn your grandparents!

Historically, this class has been lethal to
grandparents of students in the class
– More often grandmothers

This happens most around test time
– Although occasionally around the times a big
assignment is due
75
Uninitialized versus null
 Consider
String dayOfWeek;
Scanner inStream;
 What is the representation?
dayOfWeek
-
inStream
-
76
Uninitialized versus null
 Consider
String fontName = null;
Scanner fileStream = null;
 What is the representation?
fontName
null
fileStream
null
OR
fontName
fileStream
77
The null reference
 Sometimes you want a reference to point to nothing
 Use the null reference:
String s = null;
 The null reference is equivalent to a memory address of zero
(0x00000000)
 No user program can exist there
78
The null reference
 Consider:
String s = “Hello world”;
System.out.println (s.length());
 What happens?
 Java prints
out 11
s
String
- text = “Hello world"
- length = 11
- ...
+ length () : int
+ charAt ( int i ) : char
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ ...
79
The null reference
 Consider:
String s = null;
System.out.println (s.length());
 This is called accessing (or following) a null pointer/reference
 What happens?
 Java: java.lang.NullPointerException
 C/C++: Segmentation fault (core dumped)
 Windows: …
80
What happens in Windows…
81
So what is a null reference good for?
 Let’s say you had a method that returned a String when
passed some parameters
 Normally it returns a valid String
 But what if it can’t? How to deal with that?
 Return a null reference
82
References and memory
 Most modern computers are 32-bit computers
 This means that a reference takes up 32 bits
 232 = 4 Gb
 This means that a 32-bit machine cannot access more
than 4 Gb of memory!
 Well, without doing some “tricks”, at least
 Most machines come with 1 Gb memory these days
 Will come with 4 Gb in a year or so
 64-bit machines will have a maximum of 16 exabytes of
memory
 Giga, Tera, Peta, Exa
 That’s 16 billion Gb!
83
Why speling is not so important…
I cdnuolt blveieetaht I cluod aulaclty uesdnatnrd
waht I was rdanieg. The phaonmneal pweor of
thehmuan mind. Aoccdrnig to a rscheearch at
Cmabrigde Uinervtisy, it deosn't mttaer in waht
oredr the ltteers in a wrod are, the olny iprmoatnt
tihng is taht thefrist and lsat ltteer be in the rghit
pclae. The rset can be a taotl mses andyou can
sitll raed it wouthit a porbelm. Tihs is bcuseae
the huamn mnid deosnot raed ervey lteter by
istlef, but the wrod as a wlohe. Amzanig huh?
yaeh and I awlyas thought slpeling was ipmorantt.
84
Assignment
 Consider
String word1 = "luminous";
String word2 = "graceful";
word1 = word2;
Garbage
collection
time!
 Initial representation
word1
"luminous"
word2
"graceful"
85
Using objects
 Consider
Scanner stdin = new Scanner(System.in);
System.out.print("Enter your account name: ");
String response = stdin.next();
 Suppose the user interaction is
Enter your account name: artiste
reponse
stdin
"artiste"
Scanner:
86
String representation
 Consider
 String alphabet = "abcdefghijklmnopqrstuvwxyz";
 Standard shorthand representation
alphabet
"abcdefghijklmnopqrstuvwxyz"
 Truer representation
alphabet
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
y
87
z
String representation
 Consider
 String alphabet = "abcdefghijklmnopqrstuvwxyz";
 char c1 = alphabet.charAt(9);
 char c2 = alphabet.charAt(15);
 char c3 = alphabet.charAt(2);
 What are the values of c1, c2, and c3? Why?
c1
'j'
c2
'p'
c3
'c'
88
More String methods
 Consider
int v1 = -12;
double v2 = 3.14;
char v3 = 'a';
String s1 = String.valueOf(v1);
String s2 = String.valueOf(v2);
String s3 = String.valueOf(v3);
v1
-12
v2
3.14
v3
‘a’
s1
"-12"
s2
"3.14"
s3
"a"
89
Just in time for Valentine’s Day…
90
Bittersweets: Dejected sayings
I MISS MY EX
 PEAKED AT 17
 MAIL ORDER
 TABLE FOR 1
 I CRY ON Q
 U C MY BLOG?
 REJECT PILE
 PILLOW HUGGIN

ASYLUM BOUND
 DIGNITY FREE
 PROG FAN
 STATIC CLING
 WE HAD PLANS
 XANADU 2NITE
 SETTLE 4LESS
 NOT AGAIN

91
Bittersweets: Dysfunctional sayings
RUMORS TRUE
 PRENUP OKAY?
 HE CAN LISTEN
 GAME ON TV
 CALL A 900#
 P.S. I LUV ME
 DO MY DISHES
 UWATCH CMT

PAROLE IS UP!
 BE MY YOKO
 U+ME=GRIEF
 I WANT HALF
 RETURN 2 PIT
 NOT MY MOMMY
 BE MY PRISON
 C THAT DOOR?

92
Final variables
 Consider
final String POEM_TITLE = “Appearance of Brown";
final String WARNING = “Weather ball is black";
 What is the representation?
POEM_TITLE
WARNING
"Appearance of Brown"
"Weather ball is black"
The locks indicat e t he memory locat ions holds const ant s
93
Final variables
The reference cannot be
modified once it is established
In general, these attributes can be
modified through member methods
Value
object
type
constant
94
Rectangle
int x = 3;
int y = 4;
The upper-left-hand
int width = 5;
corner of the new Rectangle
int height = 2;
Rectangle r = new Rectangle(x, y, width, height);
x
3
y
4
width
5
height
2
The dimensions of
the new Rectangle
(3, 4)
r
2
Rectangle:
5
95
Final variables
 Consider
final String LANGUAGE = "Java";
The reference cannot be
modified once it is
established
LANGUAGE
"Java"
96
Rectangle
 Consider
final Rectangle BLOCK = new Rectangle(6, 9, 4, 2);
BLOCK.setLocation(1, 4);
BLOCK.resize(8, 3);
(6, 4)
(1,
9)
BLOCK
2
3
Rectangle:
4
8
97
String method usage
x
10
y
4
 Consider:
String s = "Halloween";
String t = "Groundhog Day";
v
String u = "May Day";
String v = s.substring(0,6);
“Hallow"
int x = t.indexOf ("Day", 0);
int y = u.indexOf ("Day");
String
s = t;
- text = “May
“Halloween"
“Groundhog
Day" Day"
u = null;
s
“Halloween"
t
“Groundhog Day"
u
“May Day"
- length = 7
9
13
- ...
+ length () : int
+ subString ( int m, int n ) : String
+ indexOf ( String s, int m ) : int
+ indexOf ( String s ) : int 98
+ ...
String method usage
x
10
y
 Consider:
String s = "Halloween";
String t = "Groundhog Day";
v
final String u = "May Day";
String v = s.substring(0,6);
“Hallow"
int x = t.indexOf ("Day", 0);
int y = u.indexOf ("Day");
s = t;
u = null;
Java error:
s
“Halloween"
t
“Groundhog Day"
u
“May Day"
4
cannot assign a
value to final
variable u
99
Rectangle method usage
Rectangle
 Consider:
- width = 1
7
- height = 2
Rectangle r = new Rectangle();
final Rectangle s = new
Rectangle (1, 2, 3, 4);
s
r.setWidth(5);
r.setHeight(6);
r
s.setWidth (7);
r = new Rectangle (8,9,10,11);
s = new Rectangle (12,13,14,15);
+ setWidth ( int w )
+ setHeight ( int wh )
+ setX ( int x )
+ setY ( int y )
+ ...
Rectangle
- width = 8
- height = 9
- x = 10
- y = 11
-x=3
-y=4
Rectangle
- width = 0
5
- height = 0
6
-x=0
-y=0
+ setWidth ( int w )
+ setHeight ( int wh )
+ setX ( int x )
+ setY ( int y ) 100
+ ...
Scanner review
 To initialize a Scanner object:
 Scanner stdin = new Scanner (System.in);
 Scanner stdin = Scanner.create (System.in);
 This one will not work!
 To read an int from the keyboard:
 stdin.nextInt();
 To read a double from the keyboard:
 stdin.nextDouble();
 To read a String from the keyboard:
 stdin.next();
101
Scanner usage examples
 Consider:
Scanner stdin = new Scanner (System.in);
int x = stdin.nextInt();
double d = stdin.nextDouble();
String s = stdin.next();
stdin
x
s
Scanner:
5
d
3.5
“hello world”
102
Today’s demotivators
103
Overloading
 We’ve seen a number of methods
 In the String class: substring(), charAt(), indexOf(), etc.
 In the Rectangle class: setLocation(), translate()
 Consider the substring() method in the String class
 One version: s.substring(3)
 This will return a string from the 4th character on
 Another version: s.substring (3,6)
 This version will return a string from the 3rd to the 5th
character
 There are multiple versions of the same method
 Differentiated by their parameter list
 The substring method can take one OR two parameters
105
 This is called overloading
More on overloading
 Consider the ‘+’ operator
 It can mean integer addition: 3+5 = 8
 It can mean floating-point addition: 3.0+5.0 = 8.0
 It can mean string concatenation: “foo” + “bar” =
“foobar”
 The ‘+’ operator has multiple “things” it can do
 a.k.a. the ‘+’ operator is overloaded
106
More on more on overloading
 Consider the valueOf() method in the String class
 s.valueOf (3)
 The parameter is an int
 s.valueOf (3.5)
 The parameter is a double
 s.valueOf (‘3’)
 The parameter is a char
 There are multiple versions of this method
 Differentiated by their parameter list
 Thus, the valueOf() method is overloaded
107
Accessors
 Some methods allow us to find out information about an
object
 In the Rectangle class: getWidth(), getHeight()
 These methods are called accessors
 They allow us to access attributes of the object
 An accessor is a method that allows us to find out
attributes of object
 Usually start with get in the method name
 I won’t use this terminology much, but the book uses it
108
Mutators
Some methods allow us to set information about the object
 In the Rectangle class: setLocation(), setBounds()
 These methods are called mutators
 They allow us to change (or mutate) the attributes of
an object
 A mutator is a method that allows us to set attributes of
object
 Usually start with set in the method name
 I won’t use this terminology much, but the book uses it
109
Constructors
 A constructor is a special method called ONLY when you are
creating (or constructing) and object
 The name of the constructor is ALWAYS the exact same
name as the class
 Scanner stdin = new Scanner (System.in);
 String foo = new String (“hello world”);
 There can be overloaded constructors
 Rectangle r = new Rectangle();
 Rectangle s = new Rectangle (1, 2, 3, 4);
110
Calling the Circle constructor

To create a Circle object:
c1
Circle c1 = new Circle();


This does four things:
 Creates the c1 reference
 Creates the Circle object
 Makes the c1 reference point
to the Circle object
 Calls the constructor with no
parameters
(the
‘default’
constructor)
Circle
- radius = 0.0
- PI = 3.14159…
-…
+ Circle()
+ Circle (double r)
+…
The constructor is always the first
method called when creating (or
‘constructing’) an object
111
Calling the Circle constructor

To create a Circle object:
c1
Circle c1 = new Circle(2.0);


This does four things:
 Creates the c1 reference
 Creates the Circle object
 Makes the c1 reference point
to the Circle object
 Calls the constructor with 1
double parameters (the ‘specific’
constructor)
Circle
- radius = 2.0
0.0
- PI = 3.14159…
-…
+ Circle()
+ Circle (double r)
+…
The constructor is always the first
method called when creating (or
‘constructing’) an object
112
Constructor varieties
 The default constructor usually sets the attributes of an
object to default values
 But that’s not why it’s called default (we’ll get to that
later)
 The default constructor ALWAYS takes in zero parameters
 Thus, there can be only one
 A specific constructor sets the attributes of the object to the
passed values
 We’ll get to why it’s called a specific constructor later
 The specific constructor takes in one or more parameters
 There can be more than one (via overloading)
113
Method types review
 With the exception of constructors, these names are purely
for human categorization
 Accessor: allows one to access parts of the object
 Mutator: allows one to change (mutate) a part of an object
 Constructor: used to create a object
 Default constructor: takes in no parameters
 Specific constructor: takes in one or more parameters
 Facilitator
 Any method that is not one of the above
114