Part I: Inheritance

For example, suppose we want to design two classes, B and C, that have some of the same data fields. Further suppose that class B contains some data fields (X1, X2, ..., Xn) that are not logically a part of a class C object but all the data fields in C (Y1, Y2, ..., Ym) are logically a part of a class B object. Inheritance involves defining class C so that it declares data fields Y1, Y2,...,Ym and then define class B such that it "extends" C and defines the data fields X1, X2,..., Xn. To do so, we actually use the keyword "extends" in the header of class B.

        class C {                        class B extends C {
           int Y1,                          int X1,
               Y2,...,                          X2,...,
               Ym;                              Xn;
         ...                                ...
        }                                }

If classes B and C are defined as shown above, we say that class C is the superclass, base class, or parent class of class B and class B is the subclass, derived class, or child class of class C. In the example above, the following statements are true:

        class B inherits from class C
        class B is derived from class C
        class B is a subclass of class C
        class B is a child (descendant) of class C
and
        class C is a base class of class B
        class C is a superclass of class B
        class C is the parent (ancestor) class of class B

As the descendant and ancestor terms suggest, the class hierarchies, or "family trees" in Java can be extensive. For an example of a more extended hierarchy, see the Student.java file associated with this lecture. This file contains a base class, Student, with classes HSStudent, UGStudent, and GStudent derived directly from Student; JunHighStudent and SenHighStudent derived from HSStudent; and Masters and PhD derived from GStudent.

Notice that each parent class has its data fields defined as "protected" and only the non-parent classes have "private" data fields. The "protected" visibility modifier is used only with inheritance. A protected (or public) data field of an ancestor class is part of and directly accessible to any object of a descendant class. However, to "unrelated" classes, protected data fields are like private data fields - i.e., they are inaccessible. Private data fields in an ancestor class are not directly accessible to descendant classes (although a copy is created for each descendant object, that copy cannot be directly accessed by any of the descendant object's methods).

In general, the following rules apply:

        Data Field                  ...means
      Visibility Modifier       Access Allowed to
      -------------------       -----------------
      public                    all other classes,
                                even unrelated ones

      protected                 descendants only

      private                   no related or unrelated
                                classes

Inheritance only works in one direction, i.e., the ancestor class is allowed access to NONE of the descendant classes data fields or methods, no matter how they are declared. That's why in diagrams of class hierarchies, the arrows point from child to parent class...think of visibility going in only one direction such that all the non-private members of the parent class are visible (and therefore accessible) to the child classes, but not vice versa.

Part 2: Polymorphism

For example, suppose we wanted to create an array called "whosWho", containing the 50 most remarkable students from high school through graduate school in a given region. Then, given the Student.java class hierarchy, we could define this array as follows:

         Student[] whosWho = new Student[50];

         whosWho[0] = new JunHighStudent();
         whosWho[1] = new Masters();
         whosWho[2] = new Resident();
         whosWho[3] = new UGradStudent();
         whosWho[4] = new HSStudent();
         whosWho[5] = new Student();
         whosWho[6] = new PhD();
         ...

What this means for us, as program designers, is that we can write arrays that are "generic", i.e., able to hold objects of different, but related, types. The above example shows how we would define such a generic array and how we could go about adding elements to this array.

The instanceof operator allows us to check whether the element we are accessing is a more specific type (where the most specific is the "instantiated type") than the declared type of the array. For example, after creating the elements in the whosWho array, we could count the number of Masters objects in the array as follows:

  1.    int numMasters = 0;
  2.    for (int i = 0; i < whosWho.length; i++)
  3.    {
  4.       if (whosWho[i] instanceof Masters)
  5.          numMasters++;
  6.    }

Part 3: The Java hierarchy and the Object class

     Object[] a = new Object[3];  // declare generic container
     a[0] = "One String";
     a[1] = "Two String";
     a[2] = "Last String";

     for (int j = 0; j < a.length; j++)
     {
          System.out.println(a[j].length());
     } 

     for (int j = 0; j < a.length; j++)
     {
          System.out.println(((String)a[j]).length());
     }