Topics to discuss

• Can you talk about the job search? Done.
• Can we go over wrapping?
• Can we go over some issues in skip lists?

Wrapping

Broad: Objects in one class include objects from another class and conceal those inner objects.

• The enclosing object can add/remove/change functionality
  • Add can mean "more functions"
  • Add can mean "each function has additional things"
• Example of addition: ReportingLinearStructure
  • More functions: dump
  • Additional capabilities in a function: add, get
• A few reasons to do this
  • Add capabilities in a sensible/general way
• Although I've said that we wrap objects, we also wrap functions.
  • Adding/modifying functionality
  • Protect the inner function
• What's the difference between wrapping and referencing?
  • Object wrapping usually requires referencing
  • Difference: Wrapping generally implies that the inner object is also protected in some way; references can be shared
  • Often the wrapped object is a core aspect of the wrapper
• A slightly different model (and maybe this is more like referencing)
  • Linked lists (or any of our other linked structures)

Wrapper-like patterns

• Adapters: Change the interface
  • Sam's linear structures need a get and a put with a particular semantics.

Example: Wrapping/adapting java.util.Queue to meet the taojava.util.Linear interface.

    public class LinearQueue<T>
      implements LinearStructure<T>
    {
      // +--------+------------------------------------------------------
      // | Fields |
      // +--------+

      java.util.Queue<T> core = new java.util.Queue<T>();

      // +---------+-----------------------------------------------------
      // | Methods |
      // +---------+

      public void put(T val)
        throws Exception
      {
        core.add(val);
      } // put(T)

      public T get()
        throws Exception
      {
        core.remove();
      } // remove()


      public T peek()
        throws Exception
      {
        core.element();
      } // peek()

      public boolean isEmpty()
      {
        return (core.peek() != null);
      } // isEmpty()

      public boolean isFull()
      {
        return false;
      } // isFull()

      public Iterator<T> iterator()
      {
        return core.iterator();
      } // iterator()
    } // LinearQueue

What's the difference between Comparator and Comparable?

Comparator objects provide the method compare which takes two parameters and returns an integer that describes their ordering.

Comparable objects provide the method compareTo which takes one parameter and returns an integer that desribes the ordering of the object and its parameter.

Most of the standard objects implement Comparable<SameType>.