Computer Science 15-100 (Sections T & U), Fall 2007
Class Notes:   Object-Oriented Design (1 of 2)

Logistics

1. Reading:  L&L Sections Chapter 6 (today: through 6.5)

1. Software Development Activities
   1. Gather Requirements (functional specification)
   2. Design (software design)
   3. Implement
   4. Test
       
2. Identifying Classes and Objects
    
3. Class Relationships
   1. Dependency ("uses")
   2. Aggregation ("has-a", or "part-of")
   3. Inheritance ("is-a")  [coming soon!]
       
4. Static Class Members
   1. Static Variables
   2. Static Methods
       
5. Instance Members
   1. "this"
       
6. Interfaces
   1. Some useful techniques to demonstrate interfaces:
      1. java.util.Arrays.toString   and  java.util.Arrays.sort
         String[] a = {"d", "b", "a", "c"};
         System.out.println(java.util.Arrays.toString(a)); // [d, b, a, c]
         java.util.Arrays.sort(a);
         System.out.println(java.util.Arrays.toString(a)); // [a, b, c, d]
          
      2. The enhanced "for" statement (aka "foreach")
         String[] a = {"d", "b", "a", "c"};
         for (String s : a)
            System.out.println(s);  // prints d, b, a, c (one per line)
          
   2. How do these demonstrate interfaces?
      1. sort requires an array of Comparables!
      2. The enhance for requires an Iterator (which requires an Iterable)!
          
   3. The Comparable interface:
      public interface Comparable {
           int compareTo(Object object);
      }
      -------------------------------------

      class MyDemo {
          public static void main(String[] args) {
              MyPoint[] a = { new MyPoint(6,2), new MyPoint(1,4), new MyPoint(1,1),
                              new MyPoint(3,2), new MyPoint(0,1), new MyPoint(4,8) };
              System.out.println(java.util.Arrays.toString(a));
              java.util.Arrays.sort(a);  // requires Comparable!
              System.out.println(java.util.Arrays.toString(a));
          }
      }
      
      class MyPoint implements Comparable {
          public MyPoint(int x, int y) { this.x = x; this.y = y; }
          private int x,y;
          public String toString() { return "P(" + this.x + "," + this.y + ")"; }
      
          public int compareTo(Object thatObj) {
              // sorts by "Manhattan Distance" from the origin
              MyPoint that = (MyPoint)thatObj;
              return ((this.x + this.y) - (that.x + that.y));
          }
      }

   4. Once more, with generics:
      The Comparable<T> interface:
      public interface Comparable<T> {
           int compareTo(T object);
      }
      -------------------------------------

      class MyDemo {
          public static void main(String[] args) {
              MyPoint[] a = { new MyPoint(6,2), new MyPoint(1,4), new MyPoint(1,1),
                              new MyPoint(3,2), new MyPoint(0,1), new MyPoint(4,8) };
              System.out.println(java.util.Arrays.toString(a));
              java.util.Arrays.sort(a);  // requires Comparable!
              System.out.println(java.util.Arrays.toString(a));
          }
      }

      class MyPoint implements Comparable<MyPoint> {
          public MyPoint(int x, int y) { this.x = x; this.y = y; }
          private int x,y;
          public String toString() { return "P(" + this.x + "," + this.y + ")"; }
      
          public int compareTo(MyPoint that) {
              // sorts by "Manhattan Distance" from the origin
              return ((this.x + this.y) - (that.x + that.y));
          }
      }

   5. The Iterator interface
      public interface Iterator {
           boolean hasNext();
           Object next();
           void remove();  // optional!
      }
      And the Iterable interface
      public interface Iterator {
           Iterator iterator();
      }
      -------------------------------------

      import java.util.Iterator;
      
      class MyDemo {
          public static void main(String[] args) {
              MyStrings a = new MyStrings(3);
              a.set(0,"c");
              a.set(1,"a");
              a.set(2,"b");
              System.out.println(a);  // prints [c, a, b]
              for (Object obj : a) {
                  String s = (String)obj;
                  System.out.println(s); // prints c, a, b, one-per-line
              }
          }
      }
      
      class MyStrings implements Iterable {
          public MyStrings(int size) { this.strings = new String[size]; }
          private String[] strings;
          
          public void set(int i, String val) { strings[i] = val; }
          public String get(int i) { return strings[i]; }
          public int getLength() { return strings.length; }
          public String toString() { return java.util.Arrays.toString(strings); }
          
          public Iterator iterator() { return new MyStringsIterator(this); }
      }
      
      class MyStringsIterator implements Iterator {
          public MyStringsIterator(MyStrings ms) { this.ms = ms; }
          private MyStrings ms;
          private int nextI = 0;
          
          public boolean hasNext() { return this.nextI < ms.getLength(); }
          public Object next() { return ms.get(nextI++); }
          public void remove() { // optional!
          }
      }

   6. Once more, with generics:
      The Iterator<E> interface
      public interface Iterator<E> {
           boolean hasNext();
           E next();
           void remove();  // optional!
      }
      And the Iterable<T> interface
      public interface Iterator<T> {
           Iterator<T> iterator();
      }
      -------------------------------------

      import java.util.Iterator;
      
      class MyDemo {
          public static void main(String[] args) {
              MyStrings a = new MyStrings(3);
              a.set(0,"c");
              a.set(1,"a");
              a.set(2,"b");
              System.out.println(a);  // prints [c, a, b]
              for (String s : a)
                  System.out.println(s); // prints c, a, b, one-per-line
          }
      }
      
      class MyStrings implements Iterable<String> {
          public MyStrings(int size) { this.strings = new String[size]; }
          private String[] strings;
          
          public void set(int i, String val) { strings[i] = val; }
          public String get(int i) { return strings[i]; }
          public int getLength() { return strings.length; }
          public String toString() { return java.util.Arrays.toString(strings); }
          
          public Iterator<String> iterator() { return new MyStringsIterator(this); }
      }
      
      class MyStringsIterator implements Iterator<String> {
          public MyStringsIterator(MyStrings ms) { this.ms = ms; }
          private MyStrings ms;
          private int nextI = 0;
          
          public boolean hasNext() { return this.nextI < ms.getLength(); }
          public String next() { return ms.get(nextI++); }
          public void remove() { // optional!
          }
      }

   7. Time permitting:  ArrayLists and Wrapper Classes

Carpe diem!