Class 37: Detour: Reuse through Inheritance

Held: Friday, 4 November 2005

Summary: Today we consider inheritance, a key aspect of object-oriented design.

Related Pages:

• EBoard.
• Sample Code.

Assignments

• Exam 2 distributed.

Overview:

• Polymorphism.
• Reuse.
• Inheritance.
• Inheritance in Java.
• Special issue: Constructors.
• Example.
• Inheritance and interfaces.

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
  • Polymorphism lets you reuse methods and other code by applying them to similar kinds of objects.
  • Inheritance lets you reuse and extend class definitions, creating new classes from old.

Polymorphism, Revisited

• We have already seen many instances of polymorphism in our formatted text example.
• We can create a new Surrounded object from TextLines, from HorizontallyComposed blocks of text, and from anything else that implements TextBlock
  • Note that we only had to implement the constructor for Surrounded once and it works for all of the above.
• We can print anything that implements TextBlock with something like the following

  for (int i = 0; i < tb.getLines(); i++)
    pen.println(tb.getLine(i));
  

• Almost all instances of polymorphism rely on a variety of classes providing the same methods, and therefore being used interchangably.
• Polymorphism is great for "programming ahead": Once you've written a polymorphic method or class, it will operate with not only any appropriate class that exists at the time of writing, but also with any appropriate class created in the future.

Alternative Forms of Reuse

• However, there are also kinds of reuse that are not covered naturally by polymorphism.
• For example, if we wanted to have every text block print its own code, we'd need to copy the code above to each implementer of TextBlock. That seems wasteful.
• Similarly, if we have a whole host of variant Point classes, all of them might share x and y fields.

Inheritance Basics

• Inheritance provides these forms of reuse.
• 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, as we start to think about representing points graphically, we might want ColoredPoints, which are points that add colors.
• 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 ColoredPoint
    extends Point
  {
  } // class ColoredPoint
  

  public class Integer
    extends Number 
  {
    ...
  } // class 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?
• 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 subclass constructor.

Inheriting Interfaces

• An interface can also extend another interface, using the same syntax as class extension

  public interface NewInterface
    extends OldInteger
  {
    ...
  } // interface NewInterface
  

• Interface extension is fairly simple: Any class that implements the derived interface must implement all the methods in both the derived interface (NewInterface above) and the original interface (OldInterface above).
• Since there's no problem of deciding which implementation of a method to use, Java permits multiple inheritance for interfaces.