Inheritance

When introducing objects, I discussed the idea that they are powerful tools of abstraction which allow for us to reprsent real-world things in the form of user-defined types that are subsequently managed by the Java runtime system. I had emphasized that there is a difference between a t-shirt-as-a-concept and a particular t-shirt-as-an-object. I had also mentioned that t-shirts can be abstracted away as clothing—a t-shirt is an article of clothing (it is made of some sort of fabric and it is worn to cover the body). Object-oriented programming allows us to construct types that are in relation to one another, that form a hierarchy. In Java, we call this hierarchy "inheritance".

In Object-oriented programming inheritance refers to the concept of constructing objects which take on qualities of their predecessors. Recall what you know of basic biology. There are a variety of classification strata which denote where certain living organism reside in relation to one another. Let's take the humble dog or canis lupus familiaris as an example. A dog sits under a variety of hierarchical classifications:

Living Thing
└── Animal
    ├── Arthropod
    ├── Mollusk
    └── Chordate
        ├── Fish
        ├── Reptile
        ├── Bird
        └── Mammal
            ├── Rodent
            ├── Primate
            └── Carnivore
                ├── Cat
                ├── Bear
                └── Dog ← (Canis lupus familiaris)

A dog is a living thing, an animal, a mammal, and a carnivore. Within each grouping provides more specific information about the bodily makeup of the organism and the sorts of behaviors that it might express. A mammal breathes air, a carnivore eats meat, a chordate has a spinal chord (or a spinal chord-like structure), etc.

Java allows for us to construct similar groupings through the use of class hierarchies. For example I can create an Animal class:

1: class Animal{
2:     String name;
3:     Animal(String n){
4:         name = new String(n);
5:     }
6:     void eat(){
7:         System.out.printf("%s eats!%n", name);
8:     }
9: }

I can then create a subclass of Animal called Mammal:

1: class Mammal extends Animal{
2:     Mammal(String n){
3:         super(n);
4:     }
5:     void breathe(){
6:         System.out.printf("%s breathes!%n", name);
7:     }
8: }

The extends keyword is what turns Mammal into a subclass of Animal. We say that Animal is the "superclass" of Mammal and Mammal is a subclass of Animal. It so happens that Java uses "single-inheritance" where a class may only extend a single class¹. Furthermore, in the constructor on Line 4 of Listing 2 we see a new keyword, super. super explicitly references members of the super class—when in the context of the constructor it can be used as a method call to the "super constructor" (the constructor of the superclass).

Although it may seem strange to conceptualize at first, the basics of inheritance are actually reasonably intuitive. A subclass will inherit all members (fields and methods) of the superclass. For example, Mammal gets name and eat() from Animal:

1: public class Farm{
2:     public static void main(String[] args){
3:         Mammal m = new Mammal("Lassie");
4:         m.eat();
5:         m.breathe();
6:     }
7: }

After compiling and running we get:

Lassie breathes!josephraskind@stargazer:/tmp/inheritance$ java Farm.java 
Lassie eats!
Lassie breathes!

We can see that even though m is only declared as a Mammal type we get the original eat() from Animal alongside the breathe() from Mammal! Again, this is because Mammal is a subclass of Animal and therefore inherits all of what Animal has available.

It is important to understand this does not work in the opposite direction. For example:

1: public class Farm{
2:     public static void main(String[] args){
3:         Animal a = new Animal("Lassie");
4:         a.eat();
5:         a.breathe();
6:     }
7: }

After compiling the above we get:

josephraskind@stargazer:/tmp/inheritance$ javac Farm.java 
Farm.java:5: error: cannot find symbol
        a.breathe();
         ^
  symbol:   method breathe()
  location: variable a of type Animal
1 error
error: compilation failed

We can see that Farm was incapable of compiling because the symbol breathe could not be found. This is because Animal does not have access to breathe as it is defined within a subclass---Animal has no understanding of its subclasses!

In OOP, inheritance establishes relationships between different classes. We can categorize these relationships into two camps the "is-a" and the "has-a". Let's take a look at the Dog hierarchy:

                  Animal
                +--------+
                | name   |  ← has-a String
                +--------+
                | eat()  |
                +--------+
                     △
                     |  is-a (extends)
                     |
                  Mammal
                +----------+
                | breathe()|
                +----------+
                     △
                     |  is-a (extends)
                     |
                    Dog
                +--------+
                | bark() |
                +--------+

is-a relationships:
  Dog    is-a Mammal
  Dog    is-a Animal
  Mammal is-a Animal

has-a relationships:
  Animal has-a String (name)
  Mammal has-a String (name)  ← inherited
  Dog    has-a String (name)  ← inherited

We can verify "is-a" relationships through the use of the instanceof operator:

 1: public class Farm{
 2: 
 3:     public static void checkInstance(Animal a){
 4:         System.out.printf("%s instanceOf Animal: %b%n",
 5:                            a.name,
 6:                            a instanceof Animal);
 7:         System.out.printf("%s instanceOf Mammal: %b%n",
 8:                            a.name,
 9:                            a instanceof Mammal);
10:         System.out.printf("%s instanceOf Dog: %b%n",
11:                            a.name,
12:                            a instanceof Dog);
13:     }
14: 
15:     public static void main(String[] args){
16:         Animal a = new Animal("Alfred");
17:         Mammal m = new Mammal("Margery");
18:         Dog d    = new Dog("Douglas");
19: 
20:         checkInstance(a);
21:         checkInstance(m);
22:         checkInstance(d);
23:     }
24: }

After compiling and running we get:

josephraskind@stargazer:/tmp/inheritance$ java Farm.java 
Alfred instanceOf Animal: true
Alfred instanceOf Mammal: false
Alfred instanceOf Dog: false
Margery instanceOf Animal: true
Margery instanceOf Mammal: true
Margery instanceOf Dog: false
Douglas instanceOf Animal: true
Douglas instanceOf Mammal: true
Douglas instanceOf Dog: true

Line 3 in Listing 15 might be a bit confusing, but the next chapter on polymorphism will explain how we can send in a Dog argument to an Animal parameter.

We have seen that the advantage of inheritance comes in the form of passing down all of the members associated with a superclass, the superclass's superclass, and so on. But why is this advantageous? The most obvious benefit comes in the form of code reuse. When we create Mammal we do not need to rewrite eat() because we get it for free as Mammal is a subclass of Animal. As a corollary, if we want to change eat() we only have to change it in Animal and the change will be represented in Mammal, Dog, and any other class which extends Animal. We also get to leverage a powerful type system which can do things like runtime and static typechecking to make sure that certain behaviors are capable of being performed during the execution of our programs. When we write a program that uses a Dog object we know that a Dog should have a name and should be able to invoke the functions eat(), breathe(), and bark().

1. Compile and run Listing 8 Then add a fourth class Poodle that extends Dog and adds a method groom. Instantiate a Poodle and verify it can call eat, breathe, bark, and groom. The chapter marks Dog as final — what change must you make first and why does final prevent this?
2. The chapter shows that Dog inherits eat from Animal without redefining it. Create an Animal[] containing one instance each of Animal, Mammal, and Dog and call eat on each through the array. What prints for each? What does this demonstrate about how inherited methods behave when called through a parent type reference?
3. The chapter introduces super to call parent constructors. Remove the super(n) call from Mammal's constructor and attempt to compile. What error do you get? Now add a no-argument constructor to Animal that sets name to "Unknown" and recompile without super. What value does name have? What does this tell you about when super is required?
4. Change the name field in Animal from default (package-private) access to public and recompile. Does anything break? Now change it to protected and recompile. What is the practical difference between public and protected for an inherited field? Which would you choose and why?
5. The chapter states that instanceof checks the entire inheritance chain. Write a program that creates one instance each of Animal, Mammal, and Dog and tests every combination of instanceof (e.g. dog instanceof Animal, animal instanceof Dog, etc.). Print each result, predict it before running, and explain any results that surprise you.
6. Rewrite the Animal, Mammal, and Dog hierarchy replacing inheritance with composition: Mammal should contain an Animal field rather than extending it, and Dog should contain a Mammal field. Implement eat, breathe, and bark by delegating to the contained objects. Compare the two approaches — what do you gain and what do you lose by using composition instead of inheritance here?
7. The chapter marks Dog as final. Look up Java's Math class and String class — are they also final? Why might the designers of Java have made those classes final? Give one reason why marking a class final is a deliberate design decision rather than just a restriction.
8. Add a Cat class that also extends Mammal and has a meow method. Then create an Animal[] containing a Dog and a Cat and use an enhanced for loop with instanceof to call the appropriate sound method (bark for Dog, meow for Cat) on each element. What does this exercise demonstrate about the relationship between inheritance and polymorphism?
9. The chapter shows that Mammal calls super(n) to pass the name up to Animal. Add a second field int age to Animal and update its constructor to accept both name and age. Trace the changes that must be made down through Mammal and Dog to keep everything compiling. What does this exercise reveal about the fragile base class problem?
10. The chapter shows that Java uses the extends keyword to create a hierarchy of classes. Using only what you have learned so far, design a three-level class hierarchy of your own choosing that is different from the animal example. Write out the classes with appropriate fields and methods at each level, ensuring each subclass adds something new. Instantiate one object of each class and verify that the bottom-level class has access to all methods defined at every level above it.