Transcript Chapter 4

Chapter 4
Grouping Objects
** this pointer
class Person
{
private String firstName;
private String secondName;
public Person(String firstName, String secondName)
{
firstName = “any name”; // which is this variable?
}
}
Flexible Sized Collections



When writing a program, we often need
to be able to group objects into
collections
It is typical that the number of items to
be stored will vary over time
We could create a class with a lot of
fixed fields, but in general this will not
work
Personal Notebook Example

We will model a personal notebook




Allow notes to be stored
No limit to the number of notes stored
Show individual notes
Tells how many notes are stored
Library Classes




One feature of OO languages, is the accompanying
class libraries
Library typically contain hundreds or thousands of
different classes
Java calls these libraries packages
We use library classes exactly the same way we
would our own classes
 Instances are constructed using new, and the
classes have fields, constructors and methods
 http://java.sun.com/j2se/1.5.0/docs/api/
Actual Code



Let’s look at the Notebook class code.
Notebook Project
The very first line shows how we access
the package, using an import statement



import java.util.ArrayList;
Import statements must always be
placed before class definitions in a file.
Once a class name has been imported,
we can use that class as if it were our
own.
Object Structures with
Collections

There are at least three important features
 It is able to increase its internal capacity as
required: as more items are added, it simply
makes enough room for them.
 It keeps its own private count of how many items
it is currently storing. Its size method returns the
number of objects currently stored
 It maintains the order of items you insert into it.
You can later retrieve them in the same order.

Details of how all this is done are hidden.
Object structures with
collections
Adding a third note
Numbering within Collections





It is necessary to use values starting at
zero.
Items are stored in the ArrayList
starting a number position zero
The position is known as the index
First is given index 0, the next is index
1, …
It is a common mistake to try to access
a collection outside the valid indices.
Removing Elements




When a user wants to remove an note, we
can invoke the remove method of the
notebook object
One complication of the removal process is
that it can change the index values at which
notes are stored
If a note with a low index value is removed,
then the collection moves all notes forward to
fill the hole.
Furthermore, it is possible to insert into other
than at the end.
Removal may affect
numbering
Processing a whole collection




It would be useful to list all the notes in the notebook
it find where all of them are
We have the need to do something several times, but
the number of times depends upon circumstances
that vary.
Most programming languages include loop
statements to make this possible.
Java has three sorts of loop statement.
 We will focus on its while loop.
The while loop


A while loop is one way to perform a set of
actions repeatedly, without having to write
those actions more than once.
Here is a general format
while ( loop condition )
{
loop body //statements you want to
//repeat
}
While loop pseudo code
General form of a while loop
while keyword
Boolean test
while(loop condition) {
loop body
}
Statements to be repeated
Pseudo-code example to print every note
while(there is at least one more note to be printed) {
show the next note
}
Example
/*
*
List all notes in the notebook
*/
public void listNotes()
{
int index = 0;
while ( index < notes.size() )
{
System.out.println(notes.get(index));
index++;
}
}
While vs. If



Do not confuse a while loop with an if.
Although they look similar, they operate
in very different ways
The biggest difference is that once the
body of the loop has been executed for
the first time, we go back to the test
again to see if the body should be
executed.
Iterators



Examining every item in a collection is a
very common activity.
The ArrayList class supplies an iterator
method that supplies an Iterator object
that allows us to iterate over the
collection
We must add another import statement
to use the iterator object

import java.util.Iterator;
Iterators
An Iterator supplies two methods to
iterate over a collection: hasNext and
next
Iterator it = myCollection.iterator();
while (it.hasNext())
{
//call it.next() to get the
//next object and do
something //with that object
}

Indices vs. Iterators





We have seen approaches to accessing
elements in an ArrayList
In this example, both seem equally
adequate
Java supplies many other collections
that are not as straight foreword
It may also be inefficient or impossible
to access elements through indices.
All Java collections have iterators
The Auction System Example




The Auction System Example
highestBid == null
null is a Java key word and means ‘no
object’
When a field is an object type and it is
not explicity initialized in a constructor,
that field will contain the value null
Casting
Casting is an important feature of Java
Lot lot = (Lot) it.next();
 A cast consists of the name of a type written
alone between a pair of parentheses
 Casting is commonly seen when retrieving
objects from a collection
 This is required because collections can store
any type of object
 Casting makes it clear what type of object it
is

Anonymous Objects
Anonymous object is an object without name. It is passed
directly to the method that uses it.
public void enterLot(String description)
{
lots.add(new Lot(nextLotNumber, description));
nextLotNumber++;
}



We created a new Lot object
We passed the new object to the ArrayList’s add method.