Module 5: Java objects, Part II: dynamism

• What is out? Is it a class? A method?
• Where do you find the println() method? What is its signature?

Consider this example: (source file)

public class Person {

  // Data
  String name;
  String ssn;

  // Constructors.
  public Person (String nameIn, String ssnIn)
  {
    name = nameIn;  ssn = ssnIn;
  }

  public Person ()
  {
    name = ssn= "Not initialized";
  }

  // Accessors.
  public String getName ()
  {
    return name;
  }

  public String getSSN ()
  {
    return ssn;
  }

  public String toString ()
  {
    return "Person: Name=" + name + ", ssn=" + ssn;
  }

  // Testing:
  public static void main (String[] argv)
  {
    Person p = new Person ("George", "111-11-1234");
    System.out.println (p);
  }

} // End of class "Person"
 

We will use inheritance to extend this class. Inheritance can be used for several reasons:

1. Inheritance can be used to create a "new and improved" Person object, say, by adding new data and methods: (source file)

class PersonV2 extends Person {

  // New data.
  int age;

  // New constructor.
  public PersonV2 (String nameIn, String ssnIn, int ageIn)
  {
    name = nameIn;
    ssn = ssnIn;
    age = ageIn;
  }

  // New accessor function
  public int getAge ()
  {
    return age;
  }

  // Testing.
  public static void main (String[] argv)
  {
    PersonV2 p = new PersonV2 ("Elaine", "333-33-4567", 35);
    System.out.println (p + ", age=" + p.getAge());
  }

}
   

Note:

• In this example, Person is the parent class (super class) and PersonV2 is the child class (subclass).
  
  
• Alternatively, PersonV2 derives or inherits from Person.
  
  
• Superclass members are accessible from the subclass, e.g.,

  public PersonV2 (String nameIn, String ssnIn, int ageIn)
  {
    name = nameIn;   // "name" is defined in Person
    ssn = ssnIn;     // "ssn" is defined in Person
    age = ageIn;
  }
     

and

    System.out.println (p + ", age=" + p.getAge());
    // Uses the toString() function in the superclass.
     

2. Inheritance can be used to re-write an existing class by overriding superclass methods, for example: (source file)

class PersonV3 extends Person {

  // New data.
  int age;

  // New constructor.
  public PersonV3 (String nameIn, String ssnIn, int ageIn)
  {
    name = nameIn;
    ssn = ssnIn;
    age = ageIn;
  }

  // New accessor function
  public int getAge ()
  {
    return age;
  }

  // Overriding the toString() method:
  public String toString ()
  {
    return "PersonV3: name=" + name + ", ssn=" + ssn +
           ", age=" + age;
  }

  // Testing.
  public static void main (String[] argv)
  {
    PersonV3 p = new PersonV3 ("Kramer", "666-66-1234", 38);

    // The newer toString() overrides the superclass' toString()
    System.out.println (p);
  }

} // End of class "PersonV3"
   

3. The most important use of inheritance is polymorphism.

   Suppose we want to distinguish between two types of Person's: customers and employees: (source file)

   • First, we extend Person to create a Customer.

   class Customer extends Person {
     
     // New data.
     int loyalty;   // Number of years as customer.
   
     // New constructor.
     public Customer (String nameIn, String ssnIn, int loyaltyIn)
     {
       name = nameIn;  ssn = ssnIn;  loyalty = loyaltyIn;
     }
   
     // Override toString()
     public String toString ()
     {
       return "Customer: name=" + name + ", " + loyalty +
              " years with the company";
     }
   
     // A new method.
     public double discountRate ()
     {
       if ( (loyalty >= 1) && (loyalty < 5) )
         return 0.95;  // 5% discount.
       else if ( (loyalty >= 5) && (loyalty < 10) )
         return 0.75;  // 25% discount.
       else if (loyalty >= 10)
         return 0.50;  // 50% discount.
       else 
         return 1.0;   // no discount.
     }
     
   } // End of class "Customer"
        

   • Next, we derive Employee from Person:

   class Employee extends Person {
   
     int salary;
   
     // New constructor.
     public Employee (String nameIn, String ssnIn, int salaryIn)
     {
       name = nameIn;  ssn = ssnIn;  salary = salaryIn;
     }
   
     // Override the toString() method in Person.
     public String toString ()
     {
       return "Employee: name=" + name + ", salary=" + salary;
     }
   
   } // End of class "Employee"
        

   • Finally, let's write some code to test these objects:

   public class TestPoly {
   
     public static void main (String[] argv)
     {
       Customer c = new Customer ("John", "123-12-1234", 2);
       System.out.println (c);      // What gets printed?
   
       Employee e = new Employee ("Paul", "234-23-2345", 50000);
       System.out.println (e);      // What gets printed?
   
       // Declare some Person variables.
       Person p1, p2, p3, p4;
   
       // Person variables can hold Person instances
       p1 = new Person ("George", "345-45-3456");
       p2 = new Person ("Ringo", "456-45-4567");
   
       // ... as well as subclass instances
       p3 = c;        // c is a Customer.
       p4 = e;        // e is an Employee.
   
       System.out.println ("Person data: ");
   
       // Which toString() is called?
       System.out.println (p1);
       System.out.println (p2);
   
       // Which toString() is called?
       System.out.println (p3);
   
       // Which toString() is called?
       System.out.println (p4);
   
     }
   
   } // End of class "TestPoly"
        

   Note:

   • Customer and Employee both derived from Person.
     
     
   • You can derive as many subclasses as desired from a single class.
     
     
   • Customer defined its own constructor:

     public Customer (String nameIn, String ssnIn, int loyaltyIn)
     {
       name = nameIn;  ssn = ssnIn;  loyalty = loyaltyIn;
     }
         

   This was used in

       Customer c = new Customer ("John", "123-12-1234", 2);
         

   • Similarly, Employee had its own constructor:

     public Employee (String nameIn, String ssnIn, int salaryIn)
     {
       name = nameIn;  ssn = ssnIn;  salary = salaryIn;
     }
         

   which was used as:

       Employee e = new Employee ("Paul", "234-23-2345", 50000);
         

   • Customer overrode Person's toString() method:

     public String toString ()
     {
       return "Customer: name=" + name + ", " + loyalty +
              " years with the company";
     }
         

   Note: the string "Customer" is part of the output.
   
   

   • Similarly, Employee overrode toString():

     public String toString ()
     {
       return "Employee: name=" + name + ", salary=" + salary;
     }
         

   Note: the string "Employee" is part of the output.
   
   

   • Obviously, Person instances can be created and assigned to Person variables:

     
         p1 = new Person ("George", "345-45-3456");
         p2 = new Person ("Ringo", "456-45-4567");
     

   • What is interesting is that subclass instances can also be assigned:

    
       p3 = c;        // c is a Customer.
       p4 = e;        // e is an Employee.
   

   This is similar in spirit to assigning an int to a long:

           int i = 5;
           long j = i;    // i is automatically cast into a long.
           Person p = c;  // Customer c is cast into a Person.
         

   • What is really interesting is that even after casting, the object instance seems to remember what it was:

       // Call to toString() in Customer.
       System.out.println (p3);
   
       // Call to toString() in Employee.
       System.out.println (p4);
         

   The output for these two calls is:

   Customer: name=John, 2 years with the company
   Employee: name=Paul, salary=50000
         

   Note:

   • p3 is really a Customer.
     
     
   • p4 is really an Employee.
     
     
   • The correct toString() function is called in each case!
   • This feature is known as polymorphism.
   • A superclass can be subclassed into many "morphs".
     
     
   • Each morph has access to its own functions and data even when treated as a superclass type.