Class 39: Inheritance

Held: Wednesday, 9 April 2003

Summary: Today we consider inheritance, one of the key aspects of object-oriented design.

Notes:

• What did you think about the format of yesterday's class?
• Sorry, I planned to grade homework 3. However, as you can see from my plan, the evening got away from me.
• I checked with Mr. Stone, and he agrees that the what in Think about what couses you've taken is a pronoun.
• Expect exam 3 on Friday.
• Cool talk on teaching mathematics Friday at noon in 2428. Extra credit for attending.
• We'll spend a few minutes discussing some of your options in Computer Science for next semester or next year.

Overview:

• Reuse.
• Inheritance.
• Inheritance in Java.
• Special issue; Constructors.
• Special issue: Interfaces.
• Special issue: Abstract Classes.
• Example: Prerequisites.

Reuse

• The key goal of almost all software engineering is reuse.
• That is, we build code that we can easily use in new ways.
• Two aspects of object-oriented design are particularly related to reuse: Inheritance and Polymorphism
  • Inheritance lets you reuse and extend class definitions, creating new classes from old.
  • Polymorphism lets you reuse methods by applying them to similar kinds of objects.

Inheritance Basics

• The key aspect to inheritance is the so-called is-a relationship. We say that one class of object is-a related class of object.
• The dependent class is called the subclass.
• The class it depends upon is called the superclass.
• Traditionally, subclasses automatically get all of the fields and methods of the superclass (although they may not necessary be able to access some of them because of protection issues).
• Subclasses can also override methods, providing new variants of those methods.
• In some languages, a class can inherit from multiple other classes. As you might guess, we call this multiple inheritance.
  • Multiple inheritance raises a large host of issues, particularly which version of a method to use if more than one superclasses provide it.

Inheritance in Java

• 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.
• Similarly, the designers of Java have said that every Integer is a Number.
• How do you indicate that one class is a subclass of another? With the extends keyword (rather than some variant of is-a.

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

  public class Integer
    extends Number {
    ...
  } // Integer
  

• 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();
  Number n = new Integer(5);
  

• 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)
    ...
    public Number add(Number val1, Number val2) {
      ...
    } // add(Number,Number)
    ...
      drawWithStrangeColors(new Circle());
    ...
      Number result = add(new Integer(5), new Integer(2));
  

• 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.
  • Hence, every class implicitly provides all the operations of that class.
  • Good programming practice is to override all that are appropriate.
  • We'll spend a few minutes looking at the design of that class.
  • Its methods include
• 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.

Subclass Constructors

• When you build an object in the subclass, you are implicitly building an object in the superclass.
• So, what constructors get called?
• The rule(s) in Java:
  • You build constructors for the subclass.
  • Unless you specify otherwise, the zero-parameter constructor for the superclass gets called when you construct an object in the subclass.
  • To use a different constructor in the superclass, you need to write super(parameters) as the first line of your class.

An Example: Prerequisties

• Let's look at both design and implementation issues for a component of our four-year planner.
• Prerequisities seem like a good starting point because, as we discussed, there are a variety of kinds of prerequisites.
• What kinds of prerequisites are there?
  • You must have taken course XXX.
  • You must have met prerequisite 1 and prerequisite 2. (Do you need to support the and of n different prereqs?)
  • You must have met either prerequisite 1 or prerequisite 2. (Do you need to support the or of n different prereqs?)
  • ...
• What operations should all Prerequisite objects support?
  • Check whether a collection of courses meets a prerequisite.
  • Note, this requirement suggests that we need to design a collection of courses object.
  • Probably "convert this prerequisite to a string for printing".
  • Perhaps "compare to another prerequisite".
  • More ...
• Implementation to be done or sketched in class.
• Side Note: What's the difference between a prerequisite for a course and a requirement for a major?