2 Polymorphism

Version 5.3¹

Handout examples: Equality.java, Arrays.java, Speakers.java, Overloading.java

Polymorphism ("many-formed-ness") means that a symbol can mean different things in different contexts (p. 37).

Better: Methods or operators can behave differently depending on the objects the message is sent to or the arguments it has.

2.1 Reference Types

Theme: Reference type variables allow polymorphism through storing subtypes of their declared type.

• What are some commonly used primitive types in Java?
• How are reference types different from primitive types? ²

• Diagram a reference:

  acct → instance of SavingsAccount

• All objects are represented by reference type variables. Why? ³
• What is the default value for a reference type field?
• What is the meaning of null?

• What is the default value for a reference type local variable? ⁴

Equality and equality

• If a and b are two reference type variables, what is the meaning of a == b ?
• Drake uses the distinctions "equal in a strong sense" and "equal in a weaker sense" (p. 39). == tests for equality in the strong sense: references are to the same object.
• He uses "identical" (p. 39) in exactly the opposite sense from how I understand it: two objects are "identical" for Drake if they have equal values, but they don't have to be the same object.
• Give an example of two objects which could be "equal in a weaker sense" but not "equal in a strong sense."

• Look at the equals methods and explain the code for these two classes:

  • Die (Die.java, fig. 2.4, p. 41)
  • Beetle (Beetle.java, fig. 2.5, p. 42)
  • Why are the equals methods so complex? Would they be incorrect if less complex? Inefficient?

• The distinction between the two kinds of "equal" is only needed because of the mutability of objects. If method eat mutates its object and we have

  Rabbit a, b, c;
  a = new Rabbit();
  b = a;
  c = new Rabbit();
  a.eat();

  then mutation of a guarantees mutation of b (and vice-versa) but has no effect on c (and vice-versa).

  In functional languages like Haskell, there is no mutation and therefore no need for == in the Java sense.⁵

The Object class

• The top of the Java class hierarchy is the Object class. Since all other classes are, directly or indirectly, subclasses of Object, an Object -type variable can store a reference to any object, i.e., to any instance of any class.

• The fact that Java allows a type to have subtypes (these can arise from inheritance and interfaces, both of which we take up in detail later) means that we sometimes need to distinguish between the declared type of a variable and the most specific type of its actual value (sometimes called the actual type of the value, for short).

  So if we have

  Object thing = new Beetle();

  we can distinguish between:

  • The declared type of thing is Object.
  • The most specific type of the actual value of thing is Beetle.

  This distinction creates an opportunity for polymorphism, because the variable could store different subtypes of its declared type.

Wrapper classes

• Can a variable with declared type Object store a primitive value?

  • Not directly
  • But yes if it's wrapped.
  • Wrapper classes include Int, Boolean, Double, etc.; each of these "wraps" a primitive datum as an object.

  • Why have wrapper classes?

    • If we have say an array of Object and want to store an int-type value in it, this is as close as we can get.

  • Any disadvantages in using wrapper classes?

    • The program takes more memory and more running time.

    • Prior to Java 1.5 we'd have to write something like

      Object o = new Integer(5); // or (Integer) 5
      int n = ((Integer) o).intValue();

    • Since Java 1.5 we have autoboxing and unboxing; we can just write

      Object o = 5;
      int n = (Integer) o;

      but this just hides what happens at runtime (the compiler generates code like above).

Exercise

Given:

Object o = new Object();
Object p = new Object();
Integer i = new Integer(21);
Integer j = new Integer(21);

What are the values of

1. o == p
2. o.equals(p)
3. i == j
4. i.equals(j)

See Equality.java

2.2 Arrays

Theme: array type variables allow polymorphism because they can store arrays of different size and dimension.

• Three things we must do before using an array variable:

  • Declare it:

    int [] x;

  • Allocate it (initialize the array variable):

    x = new int[10];

  • Initialize the elements of the array, or use the default element values (what are they?):

    for (int i = 0; i < x.length; i++)
      x[i] = 1; // or some other value 

• We can do all three in one statement, for small arrays:

  int [] x = new int[] {5, 7, 12}; // omit size

• How is the array x represented in memory?

Multidimensional arrays

• How is the array y represented in memory?

  int [][] y = new int [2][4];

• Could you imagine any other way of representing a 2x4 array?

• Can we access a particular row as a unit?

  • Yes: int [] row = y[0];

• Do all rows of a two-dimensional array have to have the same length?

  • No, we can initialize each row separately, creating a "ragged" array:

    int [][] y = new int [2][];
    y[0] = new int[] {1, 3, 7};
    y[1] = new int[] {5, 11, 19, 27, 38, 49, 53};

• How do arrays, even arrays of int, create an additional kind of polymorphism? ⁶

Array Example

• Arrays.java

2.3 Interfaces

Theme: interfaces provide polymorphism through type and subtypes.

• Both interfaces and classes are types. How is an interface different from a class?

  • It has no fields (except for static final fields?)
  • All its methods are public
  • Its methods have no bodies

• How do we declare an interface?

  • How:

    public interface Name {
      methodDecls ...
    }

  • Declare an interface Speaker with a speak method.

    public interface Speaker {
        public void speak ();
    }

• Why do we have interfaces?

  • They provide another form of polymorphism: one or more classes can implement an interface; a variable of that interface type can store references to instances of any of the implementing classes.
  • E.g., dogs, cats, cows, parrots, and humans might be Speakers.
  • The implementing classes are subtypes of the interface type.
  • Once again, the variable with a declared interface type stores values of some specific subtype.

• How do we define a class that implements the interface?

  1. We must declare implements 〈InterfaceName〉
  2. We must define each method declared by the interface.

  Example:

      public class Dog implements Speaker {
          public void speak () {
              System.out.println("Woof! Woof!");
          }
      }

Interfaces Example

• Speakers.java

Abstract Data Types

What is an abstract data type (ADT)?

• Every data type is abstract when we think of what it represents and does, but not how it does it (even int!)
• Interfaces are often used to declare ADTs.

2.4 Overloading

Theme: overloaded names provide another kind of polymorphism.

Overloading means that a method name is used for two or more methods (in the same class).

• These methods must differ in their signatures: the number and types of their arguments.

• Example: a cat might have different reactions to meeting dogs and mice.

  public class Cat {
  
    ...
  
    public void react (Dog dog) { ... } // run away
  
    public void react (Mouse mouse { ... } // chase
  
  }

• The compiler looks at the declared types of the actual arguments in a method call to determine which of the overloaded methods is being called.

• Would this work as intended if we have

  Cat mycat = new Cat();
  Object mymouse = new Mouse();
  mycat.react(mymouse);

• (?) What is going on in Fig. 2-27, p. 60? (Overload example)

• Does overloading add any new capabilityor power to a programming language? I.e., could we solve programming tasks in a language with overloading that we could not in a language without overloading? ⁷

Overloading Example

• Overloading.java

Summary

1. Java has 8 primitive types; all other Java types are reference types.
2. A reference is a pointer to an object (or some similar compound thing, such as an array or a class).
3. Reference type fields have null as a default initial value.
4. With reference types, use == to ask if two expressions refer to the same object (same address); use the equals method to ask if the objects referred to have equal values (e.g., corresponding parts are equal; this can be defined to mean anything that makes sense for the application, though you should not define equals in a way that makes it false when == is true.
5. Four kinds of polymorphism in Java:
   • Reference type variables can store (references to) their declared type or any subtype of it
   • Array variables can store any dimension and size of array of the declared element type
   • Interface type variables can store references to objects that are of any subtype (implementing class) of the interface.
   • Overloading allows a method name to mean different things, depending on the number and declared types of its actual arguments.
6. Arrays must be declared, allocated, and initialized.
   • An N-dimensional array (N > 1) is a 1-dimensional array of (N-1)-dimensional arrays.
   • This allows for some flexibility. For example, a two-dimensional array consists (conceptually) of rows and columns of data, but the rows need not have the same number of elements. Similarly for N-dimensional arrays, with N > 2.

Comments

Of the four kinds of polymorphism in Java, the fourth kind (method overloading) behaves very differently from the others.

In Drake's example, we have a Domino interface with two implementing classes, FieldDomino and ArrayDomino. If we have

Domino d = ...;
d.flip();

which flip method is called? It depends on the most specific type of the actual object which d refers to (recall that Domino has two implementing classes), and this is, in general, not known until run time:

d = userInput.equals("field") ? 
    new FieldDomino(5, 6) :
    new ArrayDomino(5, 6);
d.flip();

Consequently this type of method call is said to be dynamically dispatched because at run time, the type information becomes available to determine which of the flip methods is to be run.⁸

On the other hand, if we have (in some class) methods declared as

public void toss (Domino d) { ...}      // method 1
public void toss (FieldDomino d) { ...} // method 2
public void toss (ArrayDomino d) { ...} // method 3

and somewhere else (in the same class)

FieldDomino f = new FieldDomino();
ArrayDomino g = new ArrayDomino();
Domino j = new FieldDomino();
Domino k = new ArrayDomino();

then which method is called?

• toss(f) calls method 2, because the declared type of f is FieldDomino.
• toss(g) calls method 3, because the declared type of g is ArrayDomino.
• toss(j) and toss(k) calls method 1, because the declared type of j and k is Domino. It doesn't matter that they are actually (most specifically) a FieldDomino (j) and an ArrayDomino (k).

In these cases, which method is called is determined entirely by the declared type of the argument, which is known at compile time. Consequently, the compiler determines which method is called when it compiles each method call; these method calls are said to be statically dispatched because the determination is made at compile time.

A Puzzle

If we have the overloaded methods foo (Object o, String s) and foo(String s, Object o), what happens in the method call foo("A", "B")?

• What, if anything, should happen?

Footnotes