October 1, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

The Essence of OOP Using Java, Inheritance, Part 2

  • January 17, 2002
  • By Richard G. Baldwin
  • Send Email »
  • More Articles »

Java Programming Notes #1606


Preface

This lesson is one of a series of lessons designed to teach you about the essence of Object-Oriented Programming (OOP) using Java.

The first lesson in the group was entitled The Essence of OOP Using Java, Objects, and Encapsulation.  That lesson, and each of the lessons following that one, has provided explanations of certain aspects of the essence of Object-Oriented Programming using Java.  The previous lesson was entitled The Essence of OOP using Java, Inheritance, Part 1.

Necessary and significant aspects

This miniseries will describe and discuss the necessary and significant aspects of OOP using Java.

If you have a general understanding of computer programming, you should be able to read and understand the lessons in this miniseries, even if you don't have a strong background in the Java programming language.

Viewing tip

You may find it useful to open another copy of this lesson in a separate browser window.  That will make it easier for you to scroll back and forth among the different listings while you are reading about them.

Supplementary material

I recommend that you also study the other lessons in my extensive collection of online Java tutorials.  You will find those lessons published at Gamelan.com.  However, as of the date of this writing, Gamelan doesn't maintain a consolidated index of my Java tutorial lessons, and sometimes they are difficult to locate there.  You will find a consolidated index at Baldwin's Java Programming Tutorials.

Preview

This lesson builds on the previous lesson.  It is recommended that you study that lesson before embarking on this lesson.

The program discussed in this lesson extends a Radio class to produce a new class that simulates an upgraded car radio containing a tape player.

Method overriding is used to modify the behavior of a method of the Radio class named playStation, to cause that method to behave appropriately when a tape has been inserted into the tape player.

Discussion and Sample Code

Inheriting methods and variables

When you define a class that extends another class, an object instantiated from your new class will contain all of the methods and all of the variables defined in your new class.  The object will also contain all of the methods and all of the variables defined in all of the superclasses of your new class.

The behavior of the methods

The behavior of the methods defined in a superclass and inherited into your new class may, or may not, be appropriate for an object instantiated from your new class.  If those methods are appropriate, you can simply leave them alone.

Overriding to change behavior

If the behavior of one or more methods defined in a superclass and inherited into your new class is not appropriate for an object of your new class, you can change that behavior by overriding the method in your new class.

How do you override a method?

To override a method in your new class, simply reproduce the name, argument list, and return type of the original method in a new method definition in your new class.  Then provide a body for the new method.  Write code in that body to cause the behavior of the overridden method to be appropriate for an object of your new class.

Here is a more precise description of method overriding taken from the excellent book entitled The Complete Java 2 Certification Study Guide, by Roberts, Heller, and Ernest:

"A valid override has identical argument types and order, identical return type, and is not less accessible than the original method.  The overriding method must not throw any checked exceptions that were not declared for the original method."
Any method that is not declared final can be overridden in a subclass.

Overriding versus overloading

Don't confuse method overriding with method overloading.  Here is what Roberts, Heller, and Ernest have to say about overloading methods:

"A valid overload differs in the number or type of its arguments.  Differences in argument names are not significant.  A different return type is permitted, but is not sufficient by itself to distinguish an overloading method."
Car radios with built-in tape players

This lesson presents a sample program that duplicates the functionality of the program named Radio02 discussed in the previous lesson.  A class named Radio is used to define the specifics of objects intended to simulate car radios.

A class named Combo extends the Radio class to define the specifics of objects intended to simulate improved car radios having built-in tape players.

Modification of the superclass

In the program named Radio02 in the previous lesson, it was necessary to modify the superclass before extending it to provide the desired functionality. (The requirement to modify the superclass before extending it seriously detracts from the benefits of inheritance.)

No superclass modification in this lesson

The sample program (named Radio03) in this lesson uses method overriding to provide the same functionality as the previous program named Radio02, without any requirement to modify the superclass before extending it.  (Thus this program is more representative of the benefits available through inheritance than was the program in the previous lesson.)

Overridden playStation method

In particular, a method named playStation, defined in the superclass named Radio, is overridden in the subclass named Combo.

The original version of playStation in the superclass supports only radio operations.  The overridden version of playStation defined in the subclass supports both radio operations and tape operations.

(The behavior of the version of playStation defined in the Radio class is not appropriate for an object of the Combo class.  Therefore, the method was overridden in the Combo class to cause its behavior to be appropriate for objects instantiated from the Combo class.)
A complete listing of the program is shown in Listing 5 near the end of this lesson.

The class named Radio

As usual, I will discuss the program in fragments.

Listing 1 shows the superclass named Radio.  This code is shown here for easy referral.  It is identical to the code for the same class used in the program named Radio01 discussed in an earlier lesson entitled The Essence of OOP using Java, Classes.
 

class Radio{
  protected double[] stationNumber = 
                         new double[5];
                            
  public void setStationNumber(
                int index,double freq){
    stationNumber[index] = freq;
  }//end method setStationNumber

  public void playStation(int index){
    System.out.println(
            "Playing the station at " 
               + stationNumber[index]
               + " Mhz");
  }//end method playStation
  
}//end class Radio

Listing 1

Will override playStation

The class named Combo (discussed below) will extend this class named Radio.  The method named playStation, shown in boldface in Listing 1, will be overridden in the class named Combo.

If you examine the code for the playStation method in Listing 1, you will see that it assumes radio operations only and doesn't support tape operations.  That is the reason that it needs to be overridden. (For example, it doesn't know that it should refuse to play a radio station when a tape is being played.)

The Combo class

Listing 2 shows the beginning of the class definition for the class named Combo.  The Combo class extends the class named Radio.
 

class Combo extends Radio{
  
  private boolean tapeIn = false;
  //---------------------------------//
  
  public Combo(){//constructor
    System.out.println(
           "Combo object constructed");
  }//end constructor
  //---------------------------------//

Listing 2

The tapeIn variable

The most important thing about the code in Listing 2 is the declaration of the instance variable named tapeIn.

(In the program named Radio02 in the previous lesson, this variable was declared in the class named Radio and inherited into the class named Combo.  That was one of the undesirable changes required for the class named Radio in that lesson.)
In this version of the program, the variable named tapeIn is declared in the subclass instead of in the superclass.  Thus, it is not necessary to modify the superclass before extending it.

The constructor

The constructor in Listing 2 is the same as in the previous program named Radio02, so I won't discuss it further.

The overridden playStation method

The overridden version of the method named playStation is shown in Listing 3.

As you can see, this version of the method duplicates the signature of the playStation method in the superclass named Radio, but provides a different body.
 

  public void playStation(int index){
    System.out.println("Play Radio");
    if(!tapeIn){//tapeIn is false
      System.out.println(
          "  Playing the station at " 
               + stationNumber[index]
               + " Mhz");
    }else{//tapeIn is true
      System.out.println(
            "  Remove the tape first");
    }//end if/else
  }//end method playStation

Listing 3

Aware of the tape system

This overridden version of the playStation method is aware of the existence of the tape system and behaves accordingly.

Depending on the value of the variable named tapeIn, this method will either tune and play a radio station, or display a message instructing the user to remove the tape.

Which version of playStation is executed?

When the playStation method is invoked on an object of the Combo class, the overridden version of the method (and not the original version defined in the superclass) is the version that is actually executed.

Although not particularly obvious in this example, this is one of the important characteristics of runtime polymorphism.  When a method is invoked on a reference to an object, it is the type of the object (and not the type of the variable containing the reference to the object) that is used to determine which version of the method is actually invoked.

Three other instance methods

The subclass named Combo defines three other instance methods:

  • insertTape
  • removeTape
  • playTape
The code in these three methods is identical to the code in the methods having the same name in the program named Radio02 in the previous lesson.  I discussed that code in the previous lesson and won't repeat that discussion here.  You can view those methods in the complete listing of the program shown in Listing 5 near the end of this lesson.

The driver class

Listing 4 shows the code for the driver class named Radio03.
 

public class Radio03{
  //This class simulates the 
  // manufacturer and the human user
  public static void main(
                        String[] args){
    Combo myObjRef = new Combo();
    myObjRef.setStationNumber(3,93.5);
    myObjRef.playStation(3);
    myObjRef.insertTape();
    myObjRef.playStation(3);
    myObjRef.removeTape();
    myObjRef.playStation(3);
    myObjRef.playTape();
    myObjRef.insertTape();
    myObjRef.playTape();
    myObjRef.removeTape();
    myObjRef.playStation(3);
  }//end main
}//end class Radio03

Listing 4

The code in Listing 4 is also identical to the code in the program named Radio02 discussed in the previous lesson.  Therefore, I won't discuss it in detail here.

A new object of the Combo class

I present this code here solely to emphasize that this code instantiates a new object of the Combo class.  This assures that the overridden version of the method named playStation will be executed by the boldface statements in Listing 4 that invoke the playStation method.

(Although it is not the case in Listing 4, even if the reference to the object of type Combo had been stored in a reference variable of type Radio, instead of a reference variable of type Combo, invocation of the playStation method on that reference would have caused the overridden version of the method to have been executed.  That is the essence of runtime polymorphism based on overridden methods in Java.)
Program output

This program produces the following output on the computer screen:

Combo object constructed
Play Radio
  Playing the station at 93.5 Mhz
Insert Tape
  Tape is in
  Radio is off
Play Radio
  Remove the tape first
Remove Tape
  Tape is out
  Radio is on
Play Radio
  Playing the station at 93.5 Mhz
Play Tape
  Insert the tape first
Insert Tape
  Tape is in
  Radio is off
Play Tape
  Tape is playing
Remove Tape
  Tape is out
  Radio is on
Play Radio
  Playing the station at 93.5 Mhz

I will leave it as an exercise for the student to compare this output with the messages sent to the object by the code in Listing 4.

Summary

An object instantiated from a class that extends another class will contain all of the methods and all of the variables defined in the subclass, plus all of the methods and all of the variables inherited into the subclass.

The behavior of methods inherited into the subclass may not be appropriate for an object instantiated from the subclass.  You can change that behavior by overriding the method in the definition of the subclass.

To override a method in the subclass, reproduce the name, argument list, and return type of the original method in a new method definition in the subclass.  Make sure that the overridden method is not less accessible than the original method.  Also, make sure that it doesn't throw any checked exceptions that were not declared for the original method.

Provide a body for the overridden method, causing the behavior of the overridden method to be appropriate for an object of the subclass.

Any method that is not declared final can be overridden in a subclass.

The program discussed in this lesson extends a Radio class to produce a subclass that simulates an upgraded car radio containing a tape player.  Method overriding is used to modify the behavior of an inherited method named playStation to cause that method to behave appropriately when a tape has been inserted into the radio.

Method overriding is different from method overloading.  Method overloading will be discussed in the next lesson.

What's Next?

In the next lesson, I will explain the use of overloaded methods for the purpose of achieving compile-time polymorphism.

Complete Program Listing

A complete listing of the program is shown in Listing 5 below.
 
Copyright 2002, R.G.Baldwin
Simulates the manufacture and use of a 
combination car radio and tape player.
Uses method overriding to avoid 
modifying the class named Radio.

This program produces the following
output on the computer screen:
  
Combo object constructed
Play Radio
  Playing the station at 93.5 Mhz
Insert Tape
  Tape is in
  Radio is off
Play Radio
  Remove the tape first
Remove Tape
  Tape is out
  Radio is on
Play Radio
  Playing the station at 93.5 Mhz
Play Tape
  Insert the tape first
Insert Tape
  Tape is in
  Radio is off
Play Tape
  Tape is playing
Remove Tape
  Tape is out
  Radio is on
Play Radio
  Playing the station at 93.5 Mhz
**************************************/

public class Radio03{
  //This class simulates the 
  // manufacturer and the human user
  public static void main(
                        String[] args){
    Combo myObjRef = new Combo();
    myObjRef.setStationNumber(3,93.5);
    myObjRef.playStation(3);
    myObjRef.insertTape();
    myObjRef.playStation(3);
    myObjRef.removeTape();
    myObjRef.playStation(3);
    myObjRef.playTape();
    myObjRef.insertTape();
    myObjRef.playTape();
    myObjRef.removeTape();
    myObjRef.playStation(3);
  }//end main
}//end class Radio03
//===================================//

class Radio{
  //This class simulates the plans from
  // which the radio object is created.
  // This code is the same as in the
  // program named Radio01.
  protected double[] stationNumber = 
                         new double[5];
                            
  public void setStationNumber(
                int index,double freq){
    stationNumber[index] = freq;
  }//end method setStationNumber
  
  //This version of playStation doesn't
  // accommodate tape operations.
  public void playStation(int index){
    System.out.println(
            "Playing the station at " 
               + stationNumber[index]
               + " Mhz");
  }//end method playStation
  
}//end class Radio
//===================================//

class Combo extends Radio{
  
  private boolean tapeIn = false;
  //---------------------------------//
  
  public Combo(){//constructor
    System.out.println(
           "Combo object constructed");
  }//end constructor
  //---------------------------------//
  
  //Overridden playStation method. This
  // overridden version accommodates
  // tape operations.
  public void playStation(int index){
    System.out.println("Play Radio");
    if(!tapeIn){
      System.out.println(
          "  Playing the station at " 
               + stationNumber[index]
               + " Mhz");
    }else{
      System.out.println(
            "  Remove the tape first");
    }//end if/else
  }//end method playStation
  //---------------------------------//
  
  public void insertTape(){
    System.out.println("Insert Tape");
    tapeIn = true;
    System.out.println(
                       "  Tape is in");
    System.out.println(
                     "  Radio is off");
  }//end insertTape method
  //---------------------------------//
  
  public void removeTape(){
    System.out.println("Remove Tape");
    tapeIn = false;
    System.out.println(
                      "  Tape is out");
    System.out.println(
                      "  Radio is on");
  }//end removeTape method
  //---------------------------------//
  
  public void playTape(){
    System.out.println("Play Tape");
    if(!tapeIn){
      System.out.println(
            "  Insert the tape first");
    }else{
      System.out.println(
                  "  Tape is playing");
    }//end if/else
  }//end playTape
}//end class combo

Listing 5

About the author

Richard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java and XML. In addition to the many platform-independent benefits of Java applications, he believes that a combination of Java and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects involving Java, XML, or a combination of the two.  He frequently provides onsite Java and/or XML training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Java Programming Tutorials, which has gained a worldwide following among experienced and aspiring Java programmers. He has also published articles on Java Programming in Java Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

baldwin.richard@iname.com






Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel