ITEC 120 2008fall aaray, ejderrick, ibarland, jmdymacek

home—info—labs—hws—exams
textbook—java.lang docs—java.util docs—archive

lect14b
Inheritance

We've seen class Dog, where every Dog has a sound, and a method speak (which repeats that sound twice). What if we had other animals we wanted to model? Say, cats and pythons, which both had those same behaviors? However, we will still want separate classes, since some activities are specific to Dogs (like ageInDogYears()).

One solution would be lots of repeated code for speak. But (for the first time)¹ we'll see what object-oriented programming buys for us: the ability to share code between different (related) classes.

• extends, as in class B extends A:
  we say that B is the “subclass”, and A is the “superclass”.
  It means that an instance of B knows all the method declarations and definitions which are in A.
  We also say: Every B “is-a” A. Note the arrow in BlueJ — different from the “has-a” (which uses a dotted line, and whose arrowhead isn't closed).
  (click for .jar)
  Animal.java, v1
  Cat.java, v1
  Python.java, v1
  
• Call polymorphically (in an unsurprising way):
  

  // Imagine this method in some other class entirely... static String communicateHunger( Animal a ) { return a.speak() + a.speak() + a.speak() + "!"; }

  Note, incidentally, that we can call this method on either a Cat, or on a Python. This method doesn't know (and doesn't care), what subclass of Animal it gets; every Animal can speak, so this method works just fine.
• abstract: If a superclass has been declared as an abstract class, it means you can't have objects which are the supertype without actually being some specific subtype. That is: you can't call their constructor directly.

• Constructor: When constructing a Cat, we need to initialize its fields. But wait, isn't that repeated code, found in the superclass constructor? Compare to class Python, to see the proper solution:

  super is a keyword to call the superclass constructor. (The complete story on super is below.) This call should be the first line of your constructor (if it isn't there, java rewrites your subclass constructor so that it begins with the line super(). Note that if your superclass didn't have a 0-argument constructor, this will generate an error.)

• We've actually already seen inheritance: all classes implicitly extend Object. More on this in a moment.
• We can add behavior specific to new classes; for instance, perhaps Dogs can wagTail (which Cats are simply not able to do).
  (click for .jar)
  Animal.java, v2
  Cat.java, v2
  Python.java, v2
  Dog.java, v2
  
• Overriding.
  We can make Dog's speak method different from all other Animals. Call polymorphically (exciting! (?)): if we call communicateHunger, that method still doesn't know or care what type of Animal it gets; moreover, it doesn't even know exactly which method will be called! (That's okay -- the animal itself knows where it's code for speak is.)
• Note that we've seen overriding already: we've overriden toString. Similarly, equals just uses == by default, but some classes (like String) have overridden equals to do something more specific.
  Don't confuse “overriding” with the much shallower concept, “overloading”.
• (BTW:) Documenting overridding methods: If you leave off javadoc for an method which overrides another, the javadoc tool will grab the documentation from the original super-version. You can also use {@inheritDoc} to “extend” the documentation with further, more specific comments.

home—info—labs—hws—exams
textbook—java.lang docs—java.util docs—archive

©2008, Ian Barland, Radford University Last modified 2008.Dec.10 (Wed)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu