Outline

• Abstract Data Types
• Interfaces
• Class hierarchy and Inheritance

Abstract Data Types

• you don't need to know how an iPOD (or a car, or a fridge) works in order to use one!
• all you need to know is what operations it supports and how to use those operations
• abstract data types (ADTs) are a collection of data and all the operations on that data
• the data is usually protected as fields of the class
• many of the operations are public and provide access to the data

Java Interfaces

• the collection of the methods and constants of a class can be captured in a Java construct called an interface

  public interface Teacher {
    /* each of these methods is public and abstract, and that is implicit
     * so does not need to be shown in the interface
     */
    /* @param start The time at which teaching begins
       @param finish The time at which teaching stops
       @return The contents of the teaching
     */
    Voice teach(Time start, Time finish);
    /* @param question The subject that needs to be clarified
       @return The clarification
     */
  
    Voice askClarification(Voice question);
    int numberOfExams = 3;   /* implicitly "public abstract final" */
  }
  

• a Java class can then claim to implement such an interface:

  public class Edo implements Teacher { ...
  public class John implements Teacher { ...
  

  The compiler will report an error if the class fails to provide the needed methods and constants.
• code can then use these classes interchangeably, if all that is needed is the methods and constants specified by the interface:

    Teacher lectureTeacher = new Edo();
    Teacher labTeacher = new John();
    Student I = new ...();
  
    try {
      try {
        I.listen(lectureTeacher.teach(10:30, 11:45));
      } catch (NotUnderstood something) {
        I.listen(lectureTeacher.askClarification(something));
      }
    } catch (MissingInformation somethingElse) {
      /* MissingInformation could be from the teaching or the clarification */
  
      I.listen(labTeacher.askClarification(somethingElse));
    }
  

Java Interfaces

• a Java interface can be used to describe an ADT:
  • the data itself is not public, so code using the class that implements the interface has no direct access to the class's internal data structures
  • the methods each represent an operation on the data
• in-class exercise (everyone together): design an ADT for a door
• in-class exercise (groups of 2-3 people): design an ADT for a fridge
• Example code:
  • ArbitraryPrecisionInterface.java -- how would you implement this?
  • ArbitraryPrecision.java is one of several possible implementations
  • Calculate.java -- does not rely on how an arbitrary precision number is represented internally

ADT design

• an ADT can be particularly effective when it models something in the real world
• does a car ADT have to have a method that returns the car's color?
• that depends on what we have in mind for the ADT:
  • for a police application, or a showroom application, we might want such a method
  • if our only interest is to model driving time, the color method would not be necessary
  • objects in the real world are generally more complex than the models we make of them
• the features of an object that are represented in the ADT are the object's attributes
• the actions of an object that are operations of the ADT are the object's behaviors

Java classes and objects

• Java classes can implement abstract data types
• the order of data field declaration within the class does not matter
• the order of method declaration within the class does not matter
• the order of statements within a method does matter!
• an object is an instance (a specific example) of a class:

    String first = new String("1st");
    String upper = first.toUpperCase();
  

  first and upper are objects belonging to the class String
• objects in a program are generally referenced by a variable: the same variable can reference different objects at different times
• a variable is a memory location that can store an object reference, or a value of a simple type such as boolean, int, etc.
• a variable (of an object type) that does not reference an object has the special value Null. Attempting to access (reference) a method or value of this object will throw a NullPointerException
• a class variable is also known as a field or data field

Special methods

• a constructor initializes new objects of the given class
• each constructor must set the values of the fields to a valid initial value. The exact value varies depends on the class and sometimes on the constructor
• there may be more than one constructor, with different parameters
• the no-arguments constructor is called by Java when no other constructor is called by the programmer
• sometimes programmers make the data of a class protected or private, but provide accessor methods to read the value, or mutator methods to modify the value
• this still allows programmers to modify the implementation, as long as they can support the original accessor and mutator methods
• a toString method is invoked automatically by Java when the object is passed to a method or operator that needs a string

Inheritance

• a class (the subclass) is usually derived from another class (the superclass)
• when every B is an A, class B should be a subclass of class A
• this is described as inheritance, or B extends A
• for example, exceptions such as IndexOutOfBoundsException are derived from RuntimeException, which is derived from Exception
• so IndexOutOfBoundsException is a subclass of RuntimeException;
  and RuntimeException is the superclass of IndexOutOfBoundsException (and many other exceptions)
• IndexOutOfBoundsException inherits all the methods and data fields of RuntimeException
• the predefined field this in the code of a class always refers to the current object (so cannot be used in static methods)
• I could create a class ICS211 which extends UHCourse

Special class variables: this and super

public class Child extends Parent {
  private String myName;
  public Child (String name)
  {
    super ();      /* call no-argument constructor for parent */
    this.myName = name; /* initialize local data */
  }
  /* omitting the hasFeature method would give the same result */
  public boolean hasFeature(String feature)
  {
    return super.hasFeature(feature);
  }
  public String name()
  {
    return myName;
  }
}