Outline of Class 5: Inheritance and Exceptions

Miscellaneous

• Some of you have asked about how best to deal with multiple classes. Here's the basic strategy:
  • Put each class in a separate file
  • In any class that refers to another class, begin the file with import OtherClass; (this goes before the class declaration)
  • Compile all the files (with javac PingPong.java Player.java ...)
  • Run the interpreter on the class with the appropriate main() method.
• I will do my best to be available Wednesday evenings, from approximately 8-10:30 pm.
• To make up for my limited evening presence (and overall limited time this term), I'll be hosting Sunday evening dinners from 6-8pm. I won't guarantee gourmet food, but each meal will be home-cooked. Some weeks, it will just be William and I (and any of you who come), other weeks my wife or other friends or family may be there. I can probably handle four people per week, so email me with a week or two you'd like to come, and any dietary restrictions/preferences.
• Don't forget about the departmental brown bag lunches! A good chance to laugh / sleep / perhaps even learn something. We've just had two on software engineering, and the next two are on the history of CS (which, hopefully, will be more interesting).
• Exceptions are documented on pages 39--45 of Flanagan.
• As most of you have guessed, I haven't had time to check all my code. Sorry.

More on Loops

• At times, you need to exit your loops (or one repetition of a loop) early.
• For example, you might have noted an abnormal condition, or have reached termination.
• While it is always possible to provide for such early exits by intelligent use of conditionals, such conditionals can inhibit the readability of your code.
• Hence, Java provides methods for exiting loops.
• break exits the current loop (or switch).
• continue exits the current repetition of the loop (going back to the test, and, possibly, to another repetition of the loop).
• Since we often nest loops, Java also provides a mechanism for exiting nested loops. You can label a any of the loops or switches with label: statement and then use break label to break out of that statement. For example

  outer: 
  for (i = 0; i < N; ++i) {
    inner:
    for (j= 0; j < M; ++j) {
      if (meetsCondition(i,j)) {
        System.out.println(
          "Found what we were looking for at (" +
          i + "," + j + ")"
        );
        break outer;
      } // if
    } // inner for loop
    // Here's where you go if you break out of the inner loop
  } // outer for loop
  // Here's where you go if you break out of the outer loop
  

• Similarly, continue can take a label, and returns to the next iteration of the labeled loop.

Subclassing and Inheritance

• Java, like most object-oriented languages, lets you subclass existing classes to refine their functionality for particular instances.
• For example, we might have a general DrawableObject class and refine that to particular drawable objects, such as Circle or Square.
• How do you indicate that one class is a subclass of another? With the extends keyword.

  public class Circle extends DrawableObject {
    // ...
  }
  

• A subclass inherits all the methods and fields of its superclass (with some restrictions due to protection mechanisms).
• A subclass may also override any of these methods by including its own definition.
• Java allows you to use a member of a subclass anywhere a member of a superclass is permitted. For example, it is perfectly valid to write:

  DrawableObject obj = new Circle();
  

• Java is much more restrictive on using members of superclasses in place of members of subclasses.
• Why do you think Java has these restrictions?
• Java permits only single inheritance -- a particular class can only directly derive from one other class.
  • In the alternative, multiple inheritance -- a particular class can directly derive from more than one other class.
  • Single inheritance makes analysis and design much easier. Otherwise, there are potential problems with the same method name being defined in both parent classes.
  • Java provides interfaces to support many of the needs of multiple inheritance.
• Reminder: to "load" information about another class into your class file, use

  import OtherClass;

  before your class definition.

Interfaces

• Instead of relying on multiple inheritance, Java permits you to declare interfaces, collections of routines that an object can agree to support.
• For example, we might decide to may our complex numbers, which are most likely a subclass of Number agree to provide a set of drawing routines.
• Similarly, we might decide that Line objects, which would most likely be a subclass of Polygon (or some such) would also provide "mathematical" operations (so that you could add, subtract, and compare lines).
• Interface declarations look remarkably like class declarations, except that
  • You use interface instead of class
  • You cannot include fields in an interface
  • You do not give bodies to your interface's methods
• A class agrees to implement all the routines in an interface by using the implements keyword, as in

  public class Complex implements Drawable {
    // ...
  } // Comples
  

• If you implement more than one interface, separate them by commas.
• Once you've defined an interface, you can treat interfaces as classes, at least in terms of providing variables (and, I think, fields). For example, the following should be perfectly legal

  Drawable d = new Complex();