CS2514

Introduction to Java

Dr Derek Bridge

School of Computer Science & Information Technology

University College Cork

A class hierarchy

class Animal {
            
    protected String breed;
    
    public Animal(String breed) {
        this.breed = breed;
    }
    
    public String getBreed() {
        return breed;
    }
    
    public void talk() {
        System.out.print("");
    }
    
}

A class hierarchy

class Cow extends Animal {
            
    public Cow() {
        super("cows");
    }
    
    public void talk() {
        System.out.print("Moo");
    }
 
}

class Pig extends Animal {
            
    public Pig() {
        super("pigs");
    }
    
    public void talk() {
        System.out.print("Oink");
    }
    
}

class Aardvark extends Animal {
            
    public Aardvark() {
        super("aardvarks");
    }
    
    public void talk() {
        System.out.print("Snaffle");
    }
    
}

Assignment

Suppose we declare some variables of type Animal
```
Animal a1;
Animal a2;
```
Then we can construct an Animal object and assign it to one of the variables:
```
a1 = new Animal("mute swans");
```
But we can also construct a Cow and assign it to one of the variables:
```
a2 = new Cow();
```
I.e. assigning from narrower to wider type is allowed:
- e.g. assigning an int into a double
- e.g. assigning a subclass object into a superclass variable

Polymorphism

Polymorphism is the ability to take several forms
Specifically, in object-oriented programming, a variable of a particular type may reference ('point to') objects of different classes (the subclasses)

Another example:

Publication p = new ConferencePaper(....);

Method binding

But what happens here?
```
Animal a = new Cow();
a.talk();
```
Which version of talk is run?
The decision is made on the basis of the class of the object, not the type of the variable that is referencing the object
I.e. the object is of class Cow, so it is talk in Cow that is executed

Dynamic method binding

Method binding: deciding which of several methods of the same name to run
At what point does Java decide?
- at compile-time? (static method binding)
- at run-time? (dynamic method binding)
Modern object-oriented languages such as Java do it (mostly) at run-time because only then will it know exactly what class of object the variable is referencing
There is, however, a small performance degradation in doing it this way
(Advanced point: In fact, Java mixes static and dynamic binding: to gain efficiency, it uses the former for methods that cannot be overridden – ones that are private, static or final)

Illustrating all of this

Animal a = new Cow();
a.talk();
a = new Pig();
a.talk();
System.out.println(a.getBreed());
a = new Animal("Centipede");
a.talk();
System.out.println(a.getBreed());

Although variable a is of type Animal, Java didn't repeatedly execute methods in Animal.
During the program, a references various different classes of object and the method that was executed depended on what a was referencing

The power of polymorphism and dynamic method binding

One exceptionally useful exploitation of polymorphism is to have a data structure, such as an array, where the elements are declared to be of some general class, and then objects constructed from subclasses are assigned to the elements
Hence, we get a data structure of mixed kinds of objects
Then, we can work through the elements of the array, calling methods on them, knowing that, by dynamic method binding, the right methods will get executed

Teaching the world to sing

In the following, livestock is a polymorphic data structure: it can hold objects of different forms – objects that are any subclass of Animal

public class SingAlong {

    public static void main(String[] args) {
        Animal[] livestock = new Animal[3];
        livestock[0] = new Cow();
        livestock[1] = new Pig();
        livestock[2] = new Aardvark();
        
        for (int i = 0; i < livestock.length; i = i + 1) {
            System.out.print("Old MacDonald had a farm. ");
            System.out.println("Eee Eye, Eee Eye, Oh!");
            System.out.print("And on that farm he had some ");
            System.out.print(livestock[i].getBreed() + ". ");
            System.out.println("Eee Eye, Eee Eye, Oh!");
            
            for (int j = i; j >= 0; j = j - 1) {
                Animal a = livestock[j];
                System.out.print("With a '");
                a.talk();
                a.talk();
                System.out.print("' here, and a '");
                a.talk();
                a.talk();
                System.out.println("' there.");
                System.out.print("Here a '"):
                a.talk();
                System.out.print("', there a '");
                a.talk();
                System.out.println("'.");
                System.out.println("Everywhere a '");
                a.talk();
                a.talk();
                System.out.println("'.");
            }
            
            System.out.print("Old MacDonald had a farm. ");
            System.out.println("Eee Eye, Eee Eye, Oh!");
            System.out.println();
        }
    }
    
}

Discussion

A complex program without an if in sight!
Java makes the decisions about what to run for us
Adding a new subclass of Animal is easy; and there's no if to extend with another case – so nothing really changes
Widely useful:
- a data structure of employees where different subclasses have different ways of having their pay computed
- a data structure of graphics objects where each subclass has a different way of being drawn, being enlarged, etc.
- a data structure of documents where each subclass has a different implementation of a printing method

Advanced point: An admission

Actually this is not a great example of a class hierarchy
For a start, Animal should be an abstract class and talk in Animal should be an abstract method – see next lecture

But, is a class hierarchy necessary at all?

class Animal {
                   
    private String breed;
    private String noise;
    
    public Animal(String breed, String noise) {
        this.breed = breed;
        this.noise = noise;
    }
    
    public String getBreed() {
        return breed;
    }
    
    public void talk() {
        System.out.print(noise);
    }
    
}