1. CS2110: SW Development Methods
OO Design and the Java Collections Framework
(part 1)
Textbook readings:
MSD: parts of Chapter 9
We’ll skip some of this now and come back to it later
Read these:
Page 611 through Section 9.3.3
Pages
More pages here soon…

2. The Big Picture for this Unit
See how inheritance concepts are useful
Perhaps for you as you build classes
Definitely for Java class libraries that you use
Learn more about Java Collections Framework
ArrayList is part of this
Built on principles we just studied (inheritance, interfaces, etc.)
Learn how to make use of these reusable components, and the good OO principles behind their design
Along the way, learn more about class design

3. Application Framework
What’s an OOP framework?
A large set of classes developed by someone else
Partially complete: we add to it to make a complete working program
MSD text: a unified architecture, works together, seamless, common interface
Examples:
GUI frameworks: Java Swing, Microsoft WinForms and MFC (for C++)
Others: Java Collections
Often: the “main” program control is built into the framework
Not ours to worry about!
We’ll see this for Swing later

4. The Java Collections Framework
A common set of operations for “abstract” data structures
List interface: operations available on any kind of list
Set interface: operations available on any kind of set
A set of useful concrete classes that we can use
E.g. ArrayList, LinkedList, HashSet, TreeSet
A common set of operations for all Collections
Collection interface: operations we can do on any kind of Collection object
Collections class: contains static methods that can process Collection and List objects

5. Reminder You will want to use: You are less likely to
Concrete classes (e.g. ArrayList)
Collections operations (e.g. sort, shuffle, max)
References to interfaces when it makes sense
You are less likely to
Design a new Collection
But still, seeing how it’s been done will teach you good OO design principles

6. Real Collection Interfaces in Java
All collections meet Collection interface: boolean add(E obj); Iterator iterator(); int size(); boolean isEmpty(); boolean contains(E obj); boolean containsAll (Collection other); …
See Java API documentation for all methods

7. Collections and Abstract Classes
To define a new Collection, one must implement all methods -- a pain!
Better: define a skeletal implementation class
Leaves primitives undefined: add(), iterator()
Defines other methods in terms of those
Concrete collection class inherits from skeletal class
Defines “primitives”
Overrides any methods it chooses too
Java library: AbstractCollection
Implements Collection interface
You inherit from it to roll your own Collection

8. Abstract Class Methods
Some collection methods can be defined “abstractly”
Method from abstract class below uses other methods like add(), iterator methods, etc.
All of those defined in concrete subclass
public boolean addAll (Collection from) { Iterator iterFrom = from.iterator(); boolean modified = false; while ( iterFrom.hasNext() ) if ( add(iterFrom.next()) ) modified = true; return modified; }

9. Who is most likely to use Abstract Collection?
You, a regular programming building applications
Someone developing new classes for a library for others to use

10. List Interface in Java Two concrete classes for lists:
ArrayList, LinkedList
Both implement the List interface
Which extends the Collection interface and adds: E get(int index); E set(int index, E element); E remove(int index); void add(int index, E element); int indexOf(Object o); int lastIndexOf(Object o); List<E> subList(int from, int to); …
See Java API documentation for all methods

11. Set Interface in Java Two concrete classes for sets:
HashSet, TreeSet
Both implement the Set interface
Which is actually the same as the Collection interface but some methods have more specific meaning. E.g.:
boolean add(E element); // return false if duplicate
See p. 625 for methods that take a Collection as a parameter to do a contains/add/retain/remove
See Java API documentation for all methods
More on Sets later!

12. Which are legal? List<E> x = new ArrayList<E>();
List<E> x = new List<E> ();
ArrayList<E> x = new List<E>();
Collection<E> x = new ArrayList<E>();
Set<E> x = new ArrayList<E>();

13. Inheritance and Design
Why would we do: List<E> x = new ArrayList<E>();
One of three reasons we gave about why inheritance is used: Flexible design
We said (earlier):
Gives us more flexibility at run-time in calling operations on objects that might be of different types
Recall we use reference variables to “point to” objects
You know how polymorphism supports this
Now, two ideas about what makes a good design
Abstraction; Hiding Design Decisions

14. Important Principle: Abstraction
Inheritance is an example of the principle of abstraction
Inheritance of implementation (IS-A)
You can think of a subclass item as a type of some more general type of object
Same state, some common behavior
Inheritance of interface (e.g. Java interfaces)
You can think of an object as an instance of something that can be used or operated on in a certain defined way
E.g. it’s comparable, printable, playable, drawable

15. Hiding Design Decisions
The “black box” idea is important in design
Some “component” X, i.e. part of the system, is like a black box
The rest of the system knows how to interact with it through its interface (“interface” in general sense)
We swap in many different components for X as long as each has the same interface as X

16. Hiding Design Decisions in OO
In OO software:
We reference components by type, I.e. an object-reference ref defined by:
Interface or Superclass (perhaps abstract superclass)
Examples:
PlayableItem p; // abstract class TimePiece t; // interface public void syncTimeWith(TimePiece t) {…} ArrayList<PlayableItem> thePlayList;
What kind of object is the reference really pointing at?
The client-code doesn’t have to know.
But it does know what interface is supported.

17. Hiding Design Decisions
A term for hiding design decisions this way is: information hiding
But information means more than data here
It means how things are designed or implemented
An object-reference to a Java interface or a superclass is a use of abstraction
Coding using abstractions makes systems more flexible, easy to change, easier to re-use parts
Could rephrase this as “coding to abstractions”
Result: better software design
(Seems vague? Too “abstract”? Don’t worry. You’ll see more later!)

19. Iterators “Iteration” means moving through a set of items
Most basic example: using a for or while loop with an array or ArrayList
We usually use an index variable i to access each item
Major point:
We can think of iteration at a higher level of abstraction…
where details of implementation are hidden
Have “something” that helps us get first item, next time, are there any left, etc.
Generally applies to any collection

20. Iterator objects in Java
In OO languages like Java we use iterator objects to move through any Collection
Question: How do we get an iterator object? Answer: We get it from the Collection itself!
Question: What exactly does the Collection give us? Answer: We don’t really need to know! All we need to know is the Iterator interface this object implements.
Method in Collection: Iterator<E> iterator();
Iterator is an interface, so we can use it as a type and then call methods on objects of that type

21. Iterator Interface
Three fundamental methods: E next(); // where E is Collection’s element type boolean hasNext(); void remove();
remove() is “optional” (not always defined).
removes the item we last passed over
can be called once per call to next()
the only safe way to remove an item while an iteration is taking place

22. Example Iterator Code
Traverse a collection of Widgets named c and get each object, then remove it. Iterator<Widget> iter = c.iterator(); while ( iter.hasNext() ) { Widget w = iter.next(); // do something with w iter.remove(); }

23. Generics and foreach A simpler way (since Java 5.0)
A “foreach” statement simplifies that the previous idiom
Generics:
When you define a collection, you associate it with a particular type it will store
Think of every collection as having a “two-part type”
ArrayList<String> has type “ArrayList-of-Strings”
Also can define methods etc. using this bound-type

24. Example:
Example of generic collections and foreach in use: List<Double> myList = new ArrayList<Double>(); for (Double item : myList ) { // “foreach” stmt System.out.println(“List myList contains ” + item); }
Advantages:
Concise, easy to understand
Disadvantage: no iterator, so cannot call iterator methods on an item as you visit each one
Can’t call iter.remove()

25. ListIterator Any type of Collection can have an Iterator
A List is a specialized form of Collection
A List collection can give you a ListIterator object that has a richer set of methods than a “plain” iterator
See pages in MSD textbook
To get one, call the listIterator() method on a List
Can get one that starts at last item by calling: ListIterator<E> itr = lst.listIterator(lst.size()-1);
We’ll see you can move “backwards” through a List

26. ListIterator Methods
Additional methods (beyond those in Iterator): boolean hasPrevious(); E previous(); int nextIndex(); // index from 0 to size()-1 int previousIndex(); void set(E o); void add(E o); void remove() // overrides the one in Iterator
These last three are based on the cursor!

27. ListIterator and the “cursor”
Study pp. 631 in MSD textbook for details
Cursor “points to” a position between items
Or before the first item, or after the last item
Not the same as an item’s index!
remove() and set()
Affects the item just returned by next() or previous()
Can’t change an item without moving over it!
add() – adds an item in between two items
before the item just returned by next(), and
after the item just returned by previous()
All this is useful but tricky!

29. Step Back for the Big Picture
Why learn and use Iterators and ListIterators? Why not just use a for-loop and index value with an ArrayList or array?
Practical reasons:
Iterators and ListIterators work with any Collection/List class (e.g. LinkedLists, sets, maps, trees, etc.)
If you change from one Collection to another, there is much less code to change
“Theoretical”:
This is an example of procedural abstraction

30. Abstraction in CS What’s the concept of abstraction again?
Wikipedia (general def.): An abstraction is an idea, conceptualization, or word for the collection of qualities that identify the referent of a word used to describe concrete objects or phenomena.
Wikipedia (CS): In computer science, abstraction is a mechanism and practice to reduce and factor out details so that one can focus on a few concepts at a time.
Allows us to group things that “are the same”
Process of abstraction vs. an abstraction (a thing)

31. Procedural vs. Data Abstraction
An abstraction that hides details of how a data object is stored, represented, etc.
Procedural Abstraction
An abstraction that hides details associated with executing an operation or task
Sometimes people refer to Iteration Abstraction
Note that giving something a name is an important part of abstraction
I can refer to it. We understand it. We agree on it.

32. You Already Understand Data Abstraction!
Example 1: Floating point numbers:
Details we care about: sign, whole-part, fractional part, operations
In a computer:
How large/small can the whole-part be? How many digits in the fraction? (IEEE 754 standard?)
In Java, we can represent NaN (“not a number”) double d = doSomeOperation(…); if ( Double.isNaN(d) ) … // invalid double returned!
(Note use of static method defined in class Double)

33. You Already Understand Data Abstraction! (2)
Example 2: Classes and Objects
What’s a string? A sequence of characters
Has a size. We concatenate them. Other operations.
But what is it “inside”? (Do we care?)
Example 3: Classes and Superclasses (and Interfaces)
Manager extends Employee extends Person
We can treat a set of people-objects using type Person, ignoring details about subclasses

34. You Already Understand Procedural Abstraction!
Simple Methods, e.g. a sqrt() method
Hides the details of how it works
“Exposes” an interface we can use
We think of it and use it in terms of its purpose and interface
Loops and Iteration
We often think/design at a level higher than implementation
“I need a loop to do that.” (For-loop, while-loop? Does it matter?)
“I need to do this operation for each item.”
An iteration or repetition is implied.

35. End of Part 1 on this topic. What’s Next?
Controlling execution with “function objects”
Comparator classes: passing an instance to sort()
Another example of procedural abstraction
Oh wait! We did this earlier! But let’s talk about this: Why are Comparator objects a good example of abstraction? Which kind?
Java collections for Sets and Maps