Java How to Program Fourth Edition - DCC

Chapter 9 Object-Oriented Programming 447
Software reusability saves time in program development. It encourages reuse of
proven and debugged high-quality software, thus reducing problems after a system
becomes operational. These are exciting possibilities. Polymorphism enables us to write
programs in a general fashion to handle a wide variety of existing and yet-to-be-specified
related classes. Polymorphism makes it easy to add new capabilities to a system. Inheritance
and polymorphism are effective techniques for dealing with software complexity.
When creating a new class, instead of writing completely new instance variables and
instance methods, the programmer can designate that the new class is to inherit the instance
variables and instance methods of a previously defined superclass. The new class is
referred to as a subclass. Each subclass itself becomes a candidate to be a superclass for
some future subclass.
The direct superclass of a class is the superclass from which the class explicitly
inherits (via the keyword extends). An indirect superclass is inherited from two or more
levels up the class hierarchy. For example, class JApplet (package javax.swing)
extends class Applet (package java.applet). Thus, each applet class we have defined
is a direct subclass of JApplet and an indirect subclass of Applet.
With single inheritance, a class is derived from one superclass. Java does not support
multiple inheritance (as C++ does) but it does support the notion of interfaces. Interfaces
help Java achieve many of the advantages of multiple inheritance without the associated
problems. We will discuss the details of interfaces in this chapter. We consider both general
principles and a detailed specific example of creating and using interfaces.
A subclass normally adds instance variables and instance methods of its own, so a subclass
is generally larger than its superclass. A subclass is more specific than its superclass
and represents a smaller, more specialized group of objects. With single inheritance, the
subclass starts out essentially the same as the superclass. The real strength of inheritance
comes from the ability to define in the subclass additions to, or replacements for, the features
inherited from the superclass.
Every subclass object is also an object of that class’s superclass. For example, every
applet we have defined is considered to be an object of class JApplet. Also, because
JApplet extends Applet, every applet we have defined is considered to be an Applet.
This information is critical when developing applets, because an applet container can execute
a program only if it is an Applet. Although a subclass object always can be treated
as one of its superclass types, superclass objects are not considered to be objects of their
subclass types. We will take advantage of this “subclass-object-is-a-superclass-object”
relationship to perform some powerful manipulations. For example, a drawing application
can maintain a list of shapes to display. If all the shape types extend the same superclass
directly or indirectly, the drawing program can store all the shapes in an array (or other data
structure) of superclass objects. As we will see in this chapter, this ability to process a set
of objects as a single type is a key thrust of object-oriented programming.
We add a new form of member access control in this chapter, namely protected
access. Subclass methods and methods of other classes in the same package as the superclass
can access protected superclass members.
Experience in building software systems indicates that significant portions of the code
deal with closely related special cases. It becomes difficult in such systems to see the “big picture”
because the designer and the programmer become preoccupied with the special cases.
Object-oriented programming provides several ways of “seeing the forest through the trees.”
© Copyright 1992–2002 by Deitel & Associates, Inc. All Rights Reserved. 7/7/01