Class 17: Reuse through Inheritance

Held: Friday, 24 September 2004

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

Related Pages:

• EBoard.
• Examples.

Due

• Homework 17: Extend the Date Class

Assignments

• Homework 18: Interfaces vs. Inheritance
• Exam 1

Overview:

• Reuse.
• Inheritance.
• Inheritance in Java.
• Special issue: Constructors.
• Example.

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, 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
  

  public class ColoredPoint
    extends Point
  {
  } // class ColoredPoint
  

• 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.

An Example

• We'll write a rebelsky.drawing.ColoredPoint class that extends rebelsky.newvec.Point.