Class 10: Inheritance and Interfaces

Held Tuesday, February 9

Summary

• Code reuse
• Core issues in object-oriented programming
  • Inheritance
  • Polymorphism
• Interfaces
• It is likely that this class will primarily emphasize lecture and discussion, with no in-class laboratory component.
  • You are encouraged to read through and think about O2: Inheritance and O3: Interfaces, but are not required to do those labs.

Contents

Handouts

• Discussion section for lab G2: Java's Abstract Windowing Toolkit
  • Just the discussion section, so as to save paper.

Notes

• Today's class will focus on discussion, rather than labs.
• My machine was hacked today, so I lost a lot of time dealing with the problem. Sorry if I'm a little discombobulated.
• Remember: get extra credit by doing extra labs (even trying them and reporting on confusing parts

What is object-oriented programming?

• What is object-oriented programming? You've begun to see some aspects.
  • Programming with objects and classes.
  • Objects join data and functionality
  • Objects hide much of their internal structure, thereby separating the ``interface'' from the ``implementation''
• But there are many other typical characteristics of object-oriented langauges.
• The two most important ones are inheritance and polymorphism.
  • You'll find different definitions for the two, but we'll work on some today.
• Both of these are intended to support reuse.

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 {
    ...
  } // Circle
  

• A subclass inherits all the methods and fields of its superclass (with some restrictions due to protection mechanisms).
  • That is, it can use those methods and fields without explicitly defining or declaring them.
• A subclass may also override any of these methods by including its own definition.
  • That is, if a class defines any methods with the same name and argument types as the superclass, then that method is used instead.
• Inheritance is used in two ways. First, it's used to automatically provide some core functionality. In addition, it's used guarantee the functions an object will provide. Since an object inherits all of the ancestors methods, someone using the object knows that they will all be available.
• 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();
  

• Similarly, if you write a function that uses a superclass, you can pass in a member of the subclass.

    public void drawWithStrangeColors(DrawableObject obj) {
      ...
    } // drawWithStrangeColors(DrawableObject)
    ...
      drawWithStrangeColors(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?
• Note that if you do not provide an extends clause, Java assumes that your object extends java.lang.Object.
• 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.

An example: A simple document management system

• What kinds of objects?
• What kind of hierarchy?
• What fields and methods in the various objects?

Polymorphism

The example, continued

• A summarize function.

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 make 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 {
    ...
  } // Complex
  

• 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();
  

The example, concluded

• Think about documents with multiple revisions or versions (such as the student directory).

History

• Created Monday, January 11, 1999
• Added short summary on Friday, January 22, 1999