Using Objects
Chapter 3
Fall 2006
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
 In particular, each has only ONE value (or attribute)
 Objects
 Have attributes and behaviors
 An object can have multiple values (or attributes)
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.width);
 System.out.println (r.height);
 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
How well do we understand using
objects?
11
For Valentine’s Day…
12
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

13
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?

14
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.
15
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
16
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.
17
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
18
String program examples
20
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 + ".");
}
}
21
Program demo

WordLength.java
22
More String methods
 trim()
 Returns the String without leading and trailing whitespace
 Whitespace is a space, tab, or return
23
Date translation
 Goal: to translate the date from American format to standard
format
24
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)
}
}
25
Program demo

DateTranslation.java
26
Today’s demotivators
27
Classes vs. Objects
28
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
29
How well do we understand variables
versus types?
30
Classes vs. Objects
 A class is a user-defined “thing”
 Examples: String, Scanner, Rectangle, etc.
 We’ll start defining our own classes later this semester
 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
31
More on classes vs. objects
32
How well do we understand classes
versus objects?
33
Lots of piercings…
This may be a bit disturbing…
34
References
35
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
 Note that d does not have a value
36
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
37
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 now)
38
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
39
Representation
 Statements
int peasPerPod = 8;
String message = "Don't look behind the door!“
message
peasPerPod
8
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
+ ...
40
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
A period means
“follow the
reference”
- 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
+ ...
41
Shorthand represntation
 Consider:
s
String s = “Hello world”;
 Takes up a lot of
space on my
slides…
 So we’ll use a
shorthand
representation:
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
+ ...
“Hello world"
42
Examples
 Consider
String a = "excellence“;
String b = a;
 What is the representation?
a
"excellence"
b
43
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
45
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
46
An optical illusion
47
The null reference
48
Uninitialized versus null
 Consider
String dayOfWeek;
Scanner inStream;
 What is the representation?
dayOfWeek
-
inStream
-
49
Uninitialized versus null
 Consider
String fontName = null;
Scanner fileStream = null;
 What is the representation?
fontName
null
fileStream
null
OR
fontName
fileStream
50
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
51
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
+ ...
52
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: …
53
What happens in Windows…
54
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
55
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!
56
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
57
by farting
Using object examples
58
Assignment
 Consider
String word1 = "luminous";
String word2 = "graceful";
word1 = word2;
Garbage
collection
time!
 Initial representation
word1
"luminous"
word2
"graceful"
59
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:
60
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
61
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?
alphabet
"abcdefghijklmnopqrstuvwxyz"
c1
'j'
c2
'p'
c3
'c'
62
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"
63
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
64
Final variables
 Consider
final String LANGUAGE = "Java";
The reference cannot be
modified once it is
established
LANGUAGE
"Java"
65
Today’s demotivators
66
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
67
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
68
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 69
+ ...
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
70
Rectangle method usage
Rectangle
 Consider:
- width = 1
7
- height = 2
Rectangle r = new Rectangle();
final Rectangle s = new
Rectangle (3, 4, 1, 2);
s
r.setWidth(5);
r.setHeight(6);
r
s.setWidth (7);
r = new Rectangle (10,11,8,9);
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 ) 71
+ ...
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();
72
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”
73
Beware!!!
74
Overloading
76
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
77
More on 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 character at
index 3 up to (but not including!) the character at
index 6
 There are multiple versions of the same method
 Differentiated by their parameter list
 The substring method can take one OR two parameters
 This is called overloading
78
More on more on overloading
 Consider the valueOf() method in the String class
 String.valueOf (3)
 The parameter is an int
 String.valueOf (3.5)
 The parameter is a double
 String.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
79
More on methods
80
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
81
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
82
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);
83
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
84
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
85
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)
86
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
87
Today’s demotivators
88
Java documentation
89
Java documentation
90
Java packages
 Group similar classes together
 Packages we will use:
 java.lang: automatically imported by Java
 Contains the clases needed by the Java language
 java.util: contains Scanner, Vector, etc.
 Contains various utility classes
 java.text: we will use it later in the semester
 Contains classes used to manipulate text
 Any package (other than java.lang) must be imported to use
the classes within it
91
Not going over remaining
slides in this set
92
Example: last semester’s HW J2
93
Last semester’s HW J2
 Found online at
http://www.cs.virginia.edu/~asb/teaching/cs101fall05/hws/hwj2/index.html
 The HW listed 10 steps to be performed
 Used the StringBuffer class
 Which can be found at
http://java.sun.com/j2se/1.5.0/docs/api/java/lang/String
Buffer.html
 Strings are immutable
 Meaning that once you create a String, you can never
change it
 There are no mutator methods
 You can change what the String reference points to, but
94
not the String itself
Preliminaries
import java.util.*;
public class StringBufferManipulator {
public static void main (String args[]) {
// Preliminaries
System.out.println ("StringBuffer manipulator\n");
Scanner stdin = new Scanner (System.in);
// Code for steps 1 to 10 will go here
}
}
95
Step 1
 The user needs to enter two strings: one long string (say, 10
or so characters at a minimum) and a shorter string that is
contained within the longer string.
 This input should be obtained via the nextLine() method,
as using the next() method will not read in a string that
contains spaces.
// Step 1
System.out.println ("Enter a long string");
String longString = stdin.nextLine();
System.out.print ("\nEnter a shorter string within “);
System.out.println (“the long string");
String shortString = stdin.nextLine();
96
System.out.println ();
Step 2
 Create a StringBuffer object from the longer string -- this is
the StringBuffer that you will manipulate for the rest of the
homework. There are two ways to do this: create a default
constructred StringBuffer, and append() the long string to
that, or use the StringBuffer with the appropriate specific
constructor.
// Step 2
StringBuffer buffer = new StringBuffer(longString);
97
Step 3
 Include, as a comment in your program, the code for creating
the StringBuffer in the other way from step 2.
// Step 3
// StringBuffer buffer = new StringBuffer();
// buffer.append(longString();
98
Step 4
 Find the position of the small string within the StringBuffer,
and save that position.
// Step 4
int pos = buffer.indexOf(shortString);
99
These images are not animated…
100
Step 5
 Delete the small string from the StringBuffer, and print out
the result.
// Step 5
int shortLength = shortString.length();
buffer.delete (pos, pos+shortLength);
System.out.println (buffer);
101
Step 6
 Insert "CS101" into the position of the StringBuffer where the
small string was originally found (from step 3), and print out
the result
// Step 6
buffer.insert (pos, "CS101");
System.out.println (buffer);
102
Step 7
 Remove the last word from the string. You can assume that
everything from the last space (found via lastIndexOf()) to
the end of the String is the last word. Print out the result.
// Step 7
pos = buffer.lastIndexOf(" ");
int bufferLength = buffer.length();
buffer.delete(pos, bufferLength);
System.out.println (buffer);
103
Step 8
 Append " rocks" to the end of the StringBuffer, and print out
the result. Note that there is a space before the work 'rocks'.
// Step 8
buffer.append (" rocks");
System.out.println (buffer);
104
Step 9
 Delete the character at position n/2, where n is the length of
the StringBuffer. Print out the result.
// Step 9
int n = buffer.length();
buffer.deleteCharAt (n/2);
System.out.println (buffer);
105
Step 10
 Reverse the StringBuffer, and print out the result.
// Step 10
buffer.reverse();
System.out.println (buffer);
106
Program demo

StringBufferManipulator.java
107
Descargar

Quiz About [Your topic] - University of Virginia