CS2514

Introduction to Java

Dr Derek Bridge

School of Computer Science & Information Technology

University College Cork

Class hierarchies

In the real-world, classes often have subclasses
E.g. elephants are a subclass of mammals
Equivalently, by inverting our perspective, we can say that a class may have a superclass
E.g. mammals are a superclass of elephants
Sometimes subclasses themselves have subclasses
E.g. Indian elephants are, in turn, a subclass of elephants
This results in a class hierarchy
In a given hierarchy, it is sometimes necessary to distinguish the special case of being a direct or immediate subclass/superclass
E.g. Indian elephants are elephants in general are subclasses of mammal; elephant is a direct/immediate subclass of mammal

Example class hierarchy

Example class hierarchy

Example class hierarchy

University members form a class hierarchy

Our main example

Publications have a title, author and year of publication
Conference papers have a title, author, year of publication, a conference name, and start and end page numbers
Journal papers have a title, author, year of publication, a journal name, and start and end page numbers
Books have a title, author, year of publication and publisher

Duplicating the variables and methods: usually a bad approach

class Publication {
            
    private String title;
    private String authorName;
    private int yearOfPub;
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getTitle() {
        return title;
    }
    
    public String toString() {
        return author + "(" + yearOfPub + "): " + title;
    }
    
    // etc.
}

class ConferencePaper {
            
    private String title;
    private String authorName;
    private int yearOfPub;
    private String confName;
    private int startPage;
    private int endPage;
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getTitle() {
        return title;
    }
    
    public String toString() {
        return author + "(" + yearOfPub + "): " + title + ", in " + confName + ", pages " + startPage + "-" + endPage;
    }
    
    
    // etc.
    
    public void setConfName(String confName) {
        this.confName = confName;
    }
    
    public String getConfName() {
        return confName;
    }
    
    // etc.
}

Inheritance: a better approach

We indicate that one class is a subclass of another using the keyword extends
Then the subclass inherits the instance variables and instance methods of the superclass
I.e. by inheritance, the sublcass incorporates the instance variables & instance methods of the superclass
It can also extend the superclass by declaring further instance variables and methods of its own

Using inheritance

class Publication {
            
    private String title;
    private String authorName;
    private int yearOfPub;
    
        
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getTitle() {
        return title;
    }
    
    public String toString() {
        return author + "(" + yearOfPub + "): " + title;
    }
    
    // etc.
}

class ConferencePaper extends Publication {
            
    private String confName;
    private int startPage;
    private int endPage;
    
    public void setConfName(String confName) {
        this.confName = confName;
    }
    
    public String getConfName() {
        return confName;
    }
    
    // etc.
}

– objects of class ConferencePaper still have 6 instance variables and similarly with instance methods

Visibility of inherited variables

Recall: public variables are directly accessible from all classes; private variables are directly accessible only within the class in which they are defined
So, on the previous slide, the methods within ConferencePaper cannot directly assign to, retrieve from or compute with title, authorName or yearOfPub
The access modifier protected makes a variable/method visible to subclasses and (advanced) to any classes in the same package

Using `protected`

class Publication {
            
    protected String title;
    protected String authorName;
    protected int yearOfPub;
    
        
    public void setTitle(String title) {
        this.title = title;
    }
    
    public String getTitle() {
        return title;
    }
    
    public String toString() {
        return author + "(" + yearOfPub + "): " + title;
    }
    
    // etc.
}

class ConferencePaper extends Publication {
            
    private String confName;
    private int startPage;
    private int endPage;
    
    public void setConfName(String confName) {
        this.confName = confName;
    }
    
    public String getConfName() {
        return confName;
    }
    
    // etc.
}

– objects of class ConferencePaper now have 6 visible instance variables and similarly with instance methods

Questions

What about ConferencePaper's own instance variables – when might you make them protected?
Some people believe you should avoid protected, keeping the superclass variables private, thus reducing inter-dependencies between classes – but, then, how can a subclass access the inherited variables?

I don't want to inherit all the instance variables!

Too bad! Instance variables are always inherited
(Adavanced point: Actually, there is a way of 'hiding' inherited instance variables)
Rather than do this, you might do better to think about reworking your class hierarchy

I don't want to inherit all the instance methods!

Too bad! Instance methods are always inherited
However, you can override the body of an inherited method
E.g. Publication's toString can be overridden by a definition in ConferencePaper
- I.e. supply your own method body in place of the one that would be inherited
- Your new definition will have the same name, parameter list and return type but a different body

Example of overriding

class ConferencePaper extends Publication {
            
    private String confName;
    private int startPage;
    private int endPage;
    
    public void setConfName(String confName) {
        this.confName = confName;
    }
    
    public String getConfName() {
        return confName;
    }
    
    public String toString() {
        return author + "(" + yearOfPub +  "): " + title + ", in " + confName + ", pages " + startPage + "-" + endPage;
    }
    
    // etc.
}

A slightly different example of overriding

Publication's toString can still be called from ConferencePaper's instance methods by using super.toString() (if it is visible)

class ConferencePaper extends Publication {
            
    private String confName;
    private int startPage;
    private int endPage;
    
    public void setConfName(String confName) {
        this.confName = confName;
    }
    
    public String getConfName() {
        return confName;
    }
    
    public String toString() {
        return super.toString() + ", in " + confName  + ", pages " + startPage + "-" + endPage;
    }
    
    // etc.
}

Inheritance facilitates re-use

Suppose your program requires a class definition that is similar but not identical to an existing one (e.g. one in the standard library)
Define a subclass of the existing class
- inherit what you like
- override what you don't like
- extend with additional methods and variables if you want
You can do this irrespective of whether you have the source code of the existing class or not

What about constructors?

Creating objects, e.g.:

Publication p1 = new Publication("Rabbit plague",
    "Dr Mick Somatosis", 2011);
    
ConferencePaper p2 = new ConferencePaper("Chicago weather patterns",
    "Dr Wendy City", 2014, "World Climate Conference", 23, 45);

Publication would have a constructor like this:

public Publication(String title, String authorName, int yearOfPub) {
    this.title = title;
    this.authorName = authorName;
    this.yearOfPub = yearOfPub;
}

Constructors are not inherited!

So would this be the ConferencePaper constructor?

public ConferencePaper(String title, String authorName, 
    int yearOfPub, String confName, int startPage, int endPage) {
    this.title = title;
    this.authorName = authorName;
    this.yearOfPub = yearOfPub;
    this.confName = confName;
    this.startPage = startPage;
    this.endPage = endPage;
}

Ideally, to avoid duplication of code, the constructor in ConferencePaper should make use of the one in Publication
In fact, not only is this desirable, it is mandatory

Calling the superclass constructor

The first statement in ConferencePaper's constructor must call a constructor in Publication

This is done using super:

public ConferencePaper(String title, String authorName, 
    int yearOfPub, String confName, int startPage, int endPage) {
    super(title, authorName, yearOfPub);
    this.confName = confName;
    this.startPage = startPage;
    this.endPage = endPage;
}

More details on `super`

Don't confuse this use of super, which applies only to the very first statement in a constructor body, with the other use of super
There must be a constructor in the superclass with a matching signature
If you omit a call to super, Java implicitly puts one in for you anyway
- Specifically, it calls super()
- For this to work, you must have a zero-parameter constructor in the superclass
- Otherwise, you'll get a compile-time error

Advanced point: Multiple inheritance

In Java, the class hierarchy is a tree:
- A class can have at most one direct superclass (parent)
But Python supports multiple inheritance
- More then one parent, ordered from left-to-right
E.g.
```
class BarbieDoll(Toy, Girl):
    # etc.
```

CS2514

Introduction to Java

Dr Derek Bridge

School of Computer Science & Information Technology

University College Cork

Class hierarchies

Example class hierarchy

Example class hierarchy

Example class hierarchy

Our main example

Duplicating the variables and methods: usually a bad approach

Inheritance: a better approach

Using inheritance

Visibility of inherited variables

Using protected

Questions

I don't want to inherit all the instance variables!

I don't want to inherit all the instance methods!

Example of overriding

A slightly different example of overriding

Inheritance facilitates re-use

What about constructors?

Constructors are not inherited!

Calling the superclass constructor

More details on super

Advanced point: Multiple inheritance

Using `protected`

More details on `super`