Module 5: Java objects, Part II: dynamism

In our examples so far, we've used a separate class for our object of interest, and one class for testing that contains main().

For example: (source file)

class Customer {

    // Data:
    String custName;
    int bankBalance;

    // A constructor:
    public Customer (String cname, int balance)
    {
        custName = cname;
        bankBalance = balance;
    }

    // An accessor:
    public String getCustName ()
    {
        return custName;
    }

    // ... 

} // End of class "Customer"

public class DynamicExample19 {

    public static void main (String[] argv)
    {
        Customer c = new Customer ("Joe", 1000);
        System.out.println ("Name: " + c.getCustName() );
    }

}

Note:

• Here, class Customer is purely dynamic and class DynamicExample19 is purely static

• The purpose of DynamicExample19 is simply to "test" our code in Customer.

• The main function in DynamicExample19 is similar to a globally-accessible function in C.

In Java, you can include a static "test" function directly within a dynamic object, as follows: (source file)

public class Customer {

    // Dynamic data:
    String custName;
    int bankBalance;

    // Dynamic constructor:
    public Customer (String cname, int balance)
    {
        custName = cname;
        bankBalance = balance;
    }

    // Dynamic function:
    public String getCustName ()
    {
        return custName;
    }

    // A static function!
    public static void main (String[] argv)
    {
        Customer c = new Customer ("Joe", 1000);
        System.out.println ("Name: " + c.getCustName() );
    }

} // End of class "Customer"

Note:

• It certainly looks strange: a Customer object has been created from within the object.

• Note that the file must be renamed to Customer.java.

• The main method is now inside the object.

• main still acts like a "test" function.

It is possible to define both variables and methods within an object that are static.

For example: (source file)

public class Customer2 {

    // Dynamic:
    String custName;        // Instance variable.
    int bankBalance;        // Instance variable.

    // Static:
    static int numCust = 0; // Class variable

    // Constructor (dynamic):
    public Customer2 (String cname, int balance)
    {
        custName = cname;
        bankBalance = balance;
        numCust++;
    }

    // Instance method (dynamic):
    public int getName ()
    {
        return custName;
    }

    // Class method (static):
    public static int getNumCust ()
    {
       return numCust;
    }

    // Class method (static):
    public static void main (String[] argv)
    {
        Customer2 c1 = new Customer2 ("George", 10);
        Customer2 c2 = new Customer2 ("Elaine", 20);
        Customer2 c3 = new Customer2 ("Kramer", 30);
        Customer2 c4 = new Customer2 ("Jerry", 100);

        System.out.println ("There are totally " + getNumCust() + " customers");
    }

} // End of class "Customer2"

Note:

• This class has both static and dynamic members.

• In Java, dynamic members are called instance members.

• Static members are called class members.

• Example: custName is an instance variable below

  
  public class Customer2 {
  
      String custName;        // Instance variable.
      int bankBalance;        // Instance variable.
      static int numCust = 0; // Class variable
      // ...etc..
  
  }
  

  and numCust is a class variable

• Each dynamically created object has its own instance variables and methods.

• Each such object shares static data and methods.

• Thus, in our example

  
  public class Customer2 {
  
      String custName;        // Instance variable.
      int bankBalance;        // Instance variable.
  
      static int numCust = 0; // Class variable
  
      // ...etc..
  
  }
  

  there is only one numCust variable, no matter how many Customer2 objects are created.

• A static method cannot access instance variables.
  The following will not compile:

  
  public class Customer2 {
  
      String custName;        // Instance variable.
      int bankBalance;        // Instance variable.
  
      // Static method.
      public static void test ()
      {
          custName = "Blah";    // Cannot access custName.
      }
  
  } 
  

• A dynamic method can access static variables, as we saw:

  
  public class Customer2 {
  
      String custName;        // Instance variable.
      int bankBalance;        // Instance variable.  
      static int numCust = 0; // Class variable  
  
      // Instance method.  
      public Customer2 (String cname, int balance)
      {
          custName = cname;
          bankBalance = balance;
  
          // Accessing a static variable.
          numCust++;
      }
  
      // ...
  
  }
  

• You do not have to create an instance of a class to use a static method, e.g.,

  
  class ObjA {
  
      double x;
  
      public static String getName ()
      {
          return "ObjA";
      }
  
  }
  
  
  public class Test {
  
      public static void main (String[] argv)
      {
          String s = ObjA.getname();
          // No instance of ObjA was created.
      }
  
  }
  

• In general, static variables are used for:
  • Sharing constants across all instances.
  • Sharing an occasionally-modified variable across all instances.
  • Providing constants to the outside world (e.g., Math.PI).

• Generally, static methods are used for:
  • Creating "test" functions.
  • Providing instance-independent functionality to the outside world (e.g., Math.sqrt()).
  • Returning an instance to the outside world, as in:

    
    public class Customer2 {
        // ... static/dynamic data...
    
        public static Customer2 getInstance ()
        {
            // Return an object of this type.
            return new Customer2 ("Mr.X", 0);
        }
    }   
    

• Finally, note that static methods can access instance variables when given references to the instances (via parameters, say). Thus, a "comparison" method can be written as follows: source file)

  
  class Customer {
  
      String custName;
      int bankBalance;
  
      public Customer (String cname, int balance)
      {
          custName = cname;
          bankBalance = balance;      
      }
  
      public static int compare (Customer c1, Customer c2)
      {
          // c1 and c2's data is accessible.
          int b1 = c1.bankBalance;
          int b2 = c2.bankBalance;
  
          double ratio = (double) b1 / (double) b2;
  
          if ( (0.1 < ratio) && (ratio < 10) ) {
              return 0; 
          }
          else if (b1 < b2) {
              return -1;
          }
          else {
              return 1;
          }
      }
  
  }
  
  public class DynamicExample20 {
  
      public static void main (String[] argv)
      {
          Customer c1 = new Customer ("Dilbert D", 1000000);
          Customer c2 = new Customer ("Beetle B", 100000);
  
          int comp = Customer.compare (c1, c2);
  
          if (comp < 0) {
              System.out.println ("c2 is richer");
          }
          else if (comp > 0) {
              System.out.println ("c1 is richer");
          }
          else {
              System.out.println ("same balance");
          }
      }
  
  }
   

Some mysteries explained

    String s = "hello";
    int len = s.length();
    String s2 = s.substring(0,4);  // Extract first 4 chars  

 
public final class Math extends Object {
    // No constructors at all.

    // Constants: (actual value not specified)
    public static final double E;
    public static final double PI;

    // Some Class methods:
    public static int abs (int i);
    public static double abs (double d);
    public static double exp (double d);
    public static double log (double d);
    public static double floor (double d); // Returns double!
    public static double ceil (double d);  // Returns double
    public static long round (double d);

        // No instance methods

}

public class ScreenIO1 {

    public static void main (String argv[])
    {
        // Put out a prompt.
        System.out.print ("Enter string: ");

         // We have to have a try clause because
        // the function readLine throws an exception.
        try {
            // These are the key steps in setting up the read operation.
            InputStreamReader isr = new InputStreamReader (System.in);
            LineNumberReader lr = new LineNumberReader (isr);

            // Now read the input line.
            String inputLine = lr.readLine ();

            // Echo it.
            System.out.println ("Echo: " + inputLine);
        }
        catch (IOException e) {
            // If there was a problem...
            System.out.println (e);
        }
    }

}

  System.out.println ("Number of primes below 100: ");
  System.out.println (25);
  

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);
    }

} 

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);
       }
   
   }
   

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.
             }
       }
       
     } 
     

   • 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;
       }
   
   } 
   

   • 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);
     
         }
     
     } 
     

   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.

Constructor chaining is a way of using a superclass's constructor:

• First, recall the constructors in Person

  
  public class Person {
  
        // ... stuff ...
  
      // Constructors.
      public Person (String nameIn, String ssnIn)
      {
          name = nameIn;  ssn = ssnIn;
      }
  
      public Person ()
      {
          name = ssn= "Not initialized";
      }
  
    // ... stuff ...
  
  }
  

• Next, recall how Customer was derived from Person:

  
  class Customer extends Person {
    
      // ... stuff ...
  
      // New constructor.
      public Customer (String nameIn, String ssnIn, int loyaltyIn)
      {
          name = nameIn;  ssn = ssnIn;  loyalty = loyaltyIn;
      }
  
      // ... stuff ...
  }
  

• Here, similar assignments are repeated. Is there a way of using the superclass's constructor?
  Yes:

  
  class Customer extends Person {
    
       // New data.
      int loyalty;  
  
      // New constructor.
      public Customer (String nameIn, String ssnIn, int loyaltyIn)
      {
          // This is like calling Person (nameIn, ssnIn).
          super (nameIn, ssnIn);
  
          // Subclass data.
          loyalty = loyaltyIn;
      }
  
      // Override toString()
      public String toString ()
      {
          return "Customer: name=" + name + ", " + loyalty +
                 " years with the company";
      }
    
  }
  

• Here, the reserved word super is used for a function call to the superclass' constructor.

• The call to super must match the signature of at least one constructor in the superclass.

• The super call must be the first line in any constructor of the subclass, even before any declarations of local variables.

  This method of using a superclass' constructor is called constructor chaining.
  (It is recommended).

The default in constructor chaining is worth noting because it can cause a compiler error if mishandled:

• The following is true in Java:

  Whenever a class does not have a constructor, Java automatically creates a no-parameter constructor.

• The following is also true:

  If a subclass does not explicitly call its superclass constructor, an implicit call to super() is added to every constructor in the subclass

  For example, consider the older version of Customer (which didn't have the super call).

  
  class Customer extends Person {
    
      // ... stuff ...
  
      // New constructor.
      public Customer (String nameIn, String ssnIn, int loyaltyIn)
      {
          // There is an implicit call to super() here.
          name = nameIn;  ssn = ssnIn;  loyalty = loyaltyIn;
      }
  
      // ... stuff ...
  }
  

• But what constructor of Person does the no-parameter super() call invoke?
  Answer: the compiler looks in Person for a constructor with the signature:

  
    public Person ()
  

• This is why we had to have the constructor

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

  in Person.

• Let's say you do NOT define a no-parameter constructor for a superclass.

  
  class A {
      int i;
  
      public A (int k) // Takes a parameter.
      { 
          i = k; 
      } 
  
      public someMethod (int j) 
      { 
          i = j; 
      } 
  
  }
  

• Suppose no constructor is defined for a subclass.

    
  class B extends A {
  
      double x;
      // No constructor at all.
  
  }
  

• Then, the compiler will create a default constructor for the subclass B.
• This default constructor will contain the call super().
• But there isn't a no-parameter constructor in superclass A.
  A compiler error!

Inheritance - further inheritance from a subclass

Just as casting was applied to basic types, casting can be applied to objects:

• Recall what casting meant for basic types:

  
      int i = 5;
      long j = 6;
  
      j = i;         // Automatic cast.
  
      i = (int) j;   // Explicit cast required (because of
                     // potential information loss)
  

• Now consider this example with objects: (source file)

  
  class Customer extends Person {
    
      // ... code not shown ...
  
  } 
  
  
  public class TestPoly2 {
  
      public static void main (String[] argv)
      {
          Customer c = new Customer ("Gullible Gus", "555-55-5678", 5);
  
          // Automatic cast.
          Person p = c;   
  
          // Explicit cast required.
          Customer c2 = (Customer) p;
      }
  } 
  

• Similarly, an object can be automatically cast to any ancestor in a hierarchy of inheritance.

• An explicit cast is required to cast to a descendant.

• Warning: you must know what you are doing when you cast "down": (source file)

  
  public class TestPoly3 {
  
      public static void main (String[] argv)
      {
          Customer c = new Customer ("Gullible Gus", "555-55-5678", 5);
          Person p = new Person ("Zany Zoe", "112-12-1212");
  
          // This is OK because p2 is really a Customer:
          Person p2 = c;
          Customer c2 = (Customer) p2;
  
          // This, on the other hand, will generate a 
          // run-time exception because p is not a Customer:
          Customer c3 = (Customer) p;
      }
  } 
  

Exercise 5.14:

1. Write code (in a single file) to derive class B from class A and then to derive class C from class B. For each class, create a no-parameter constructor that simply prints out to screen the name of the class. Then, create an instance of class C. What gets printed out?
2. Can static variables be inherited? Find out by defining a class A with a static integer variable i and deriving class B. Initialize and print i in the body of the constructors of both A and B (Use no-parameter constructors). Create instances of A and B and test. (Put all your code for this second question in a single file).

Review

Java defines a special class called Object:

• Object is sort-of the "parent" of all classes, from which all classes derive, whether you specify it or not.

• Thus, even if you don't explicitly say

  
  class ObjA extends Object {
  }
  

  Java actually derives every class from Object.

• The definition of Object (in package java.lang) includes:

  
  public class Object {
      // No-parameter constructor.
      public Object ();
      public String toString();
      public boolean equals (Object obj);
      //... and other methods...
  }
  

• Every class instance can be automatically cast into an Object instance, e.g.,

  
      ObjA a = new ObjA();
   
      // Automatic cast
      Object ob = a;
  
      //...later...
      a = (ObjA) ob;
  

• This language feature turns out to be very useful in writing generic code, e.g., a linked list that is defined to contain Object's but actually contains anything.