Class 38: Inheritance

Held: Thursday, 8 April 2004

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

Related Pages:

• EBoard.
• EIJ, Chapter O2.

Assignments:

• Read EIJ, Chapter O3.
• Begin Homework 5.

Notes:

• Cool convo!
• Questions on Homework 5?

Overview:

• Reuse.
• Inheritance.
• Inheritance in Java.
• Special issue: Constructors.
• Special issue: Interfaces.
• Special issue: Abstract Classes.
• Lab.

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 subclass constructor.

Lab

• Do O2-O5 of lab O2.
• Be prepared to reflect.