Section 9.2 Basics of Inheritance
Inheritance is a relationship that we can established between classes. When one class inherits another, the inherited class can be thought of as providing a kind of default implementation for any class that inherits it. Inherited classes are often referred to a base classes, superclasses, or parent classes, and inheriting classes are called derived classes, subclasses, or child classes. We’ll use the first set of terms. In Java’s implementation of inheritance, a base class may be related to one or more derived class, but a derived class may inherit at most one base class. This is referred to as single inheritance.
When one class inherits another, if a method is invoked or an instance variable is accessed on the derived class, but the derived class does not implement it, Java will search for the missing member in the inherited class. This will continue if the base class inherits another class, and so on up the inheritance hierarchy. Inheritance is a way to share a single implementation of certain methods and instance variables in one class with many other classes.
Subsection 9.2.1 Benefits of Inheritance
Inheritance solves the code duplication problem. If a method in a base class needs updating, any changes made are inherited automatically by all derived classes, no extra effort required. This reduces the chance for errors caused by neglecting to make necessary changes to all implementations of a shared method. Of course, if an error is made in the base class method, all derived classes inherit the same broken method. But fixing that error in the single base class implementation also means that the corrected method is fixed everywhere.
Another way to think about a base class is as a default implementation of some group of classes; it is a head start when implementing another variation of a class within a related group. When a new class inherits a base class, it starts with all the shared members of that base class, automatically. The only requirement for implementing that new derived class is to implement the members that make the derived class distinct from the base class, a form of specialization. Typically, this requires much less work than starting over with an empty class.
In terms of the DoodlePad shape classes, recognise that there is quite a lot of shared behavior, including position, size, colors, text, etc. The one behavior that is unique to each shape class is its graphical representation, that is, how its drawn. It won’t surprise you that DoodlePad shape classes benefit quite a lot from inheritance.
Subsection 9.2.2 Using Inheritance
To establish an inheritance relationship between a derived class and a base class, add the extends keyword and the base class name to the right of the first line in a derived class declaration. For example, in DoodlePad, all shape classes inherit a base class named Shape, so each shape class starts with a declaration like the following. Have a look at any one of the shape classes in the DoodlePad source code 1 .
public class Rectangle extends Shape { …
This one addition to a class declaration has the potential to add quite a number of default behaviors, giving you as the developer a significant head start to completing your new class implementation.
Subsection 9.2.3 A Better LED Class
Let’s revisit our LED class from Section 8.3. Rather than encapsulate an Oval object, let’s set up our LED class to extend the Oval class so that it starts with (inherits) all Oval behavior by default. This means that we no longer need to instantiate and manage an Oval class in LED. The LED class now has access to all the behavior of an Oval class through the inheritance relationship, and so LED behaves like an Oval. One implication of this is that, instead of relaying method invocations to an encapsulated Oval object (e.g. setFillColor(…)) the LED class itself has access to these methods and can invoke them directly. Even though LED does not implement Oval methods, inheritance takes care of finding suitable implementations automatically in the Oval base class.
// LED.java (version 6)
// A simple LED display class that extends Oval
import doodlepad.*;
public class LED extends Oval { // Extend Oval
private boolean on; // Tracks state of LED object
private LEDColor color; // LED Color
// Overloaded constructor defaults color to RED
public LED(double x, double y) {
this(x, y, LEDColor.RED); // Default to RED
}
public LED(double x, double y, LEDColor color) {
super(x, y, 30, 30); // Invoke base class constructor
this.setColor(color); // Set LED on color
this.turnOff(); // Init state
}
// Turn on LED
public void turnOn() {
this.on = true;
switch (this.color) {
case RED:
this.setFillColor(255, 0, 0);
break;
case GREEN:
this.setFillColor(0, 255, 0);
break;
case BLUE:
this.setFillColor(0, 0, 255);
break;
case YELLOW:
this.setFillColor(255, 255, 0);
break;
}
}
// Turn off LED
public void turnOff() {
this.on = false;
this.setFillColor(100, 100, 100);
}
// Return state of LED
public boolean isOn() {
return this.on;
}
// Set LED Color when illuminated
public void setColor(LEDColor color) {
this.color = color;
}
// Get LED Color when illuminated
public LEDColor getColor() {
return this.color;
}
// String representation of an LED object
public String toString() {
return "LED is" + (this.isOn() ? "" : " not") + " on";
}
// --- Test LED
public static void main(String[] args) {
// Create LED objects
LED led1 = new LED(100, 100);
LED led2 = new LED(200, 100);
// Change LED colors
led1.setColor(LEDColor.BLUE);
led2.setColor(LEDColor.YELLOW);
// Turn on both LED objects
led1.turnOn();
led2.turnOn();
System.out.println( led1 );
}
}
// Enum for LED Color constants
enum LEDColor { RED, GREEN, BLUE, YELLOW };
LED.java (version 6)Let’s compare Listing 9.2.1 with Listing 8.3.4 The first thing to notice is that the LED class no longer declares a private
light instance variable. This is no longer necessary because the LED itself is a kind of Oval, a specialized Oval, so no additional Oval object is required. Nevertheless, initialization is required. Because the LED is a kind of Oval, it must perform whatever initialization that an Oval requires, which is implemented by the Oval constructor. To invoke the Oval constructor, we can use the super keyword. In the second LED constructor, in place of the line that initialized the light instance variable, we now invoke the base class constructor using the line super(x, y, 30, 30). This relays the (x, y) LED constructor parameter values to the base class constructor, and sets the LED size to 30×30.Note how the
super keyword can invoke an alternative constructor in a base class in a manner directly analogous to the way we used the this keyword to invoke an overloaded alternative constructor in the current class. Similarly, we are able to use the super keyword to access the scope of the base class directly in a manner directly analogous to the way we used the this keyword to access the current object scope. The this and super keywords should occupy adjacent places in the part of your brain that holds all Java knowledge.With the removal of the
light instance variable, we must replace all references to this.light. For example, in the turnOn() and turnOff() methods, statements like this.light.setFillColor(…) are now shortened to this.setFillColor(…). The LED class does not implement the setFillColor(…) method directly, but LED extends Oval, and Oval provides access to the method through inheritance. Nice.Other than these changes, the remainder of the LED class remains unchanged. The output from this version of LED is identical to Figure 8.3.5. Using inheritance we were able to remove several references from the derived class because we can now use the inherited methods from the base class. In fact, we gain access to many more methods from the base class, which can be applied to expanding LED by invoking them directly, without the need to relay the method to an encapsulated Oval object.
Subsection 9.2.4 Blocking Inheritance
As a final note, you may decide that you do not want a class that you define to be extended. You can accomplish this by adding the
final modifier to your class declaration.public final class MyFinalClass( …
There may be something quirky about your class implementation that prevents a derived class from working correctly. Adding the
final modifier to your class declaration will tell the Java compiler to forbid new classes from extending the final base class.github.com/russomf/doodlepad/tree/master/src/doodlepad
