Programming in Java: Combining Objects

Dr. Martin Chapman
programming@kcl.ac.uk
martinchapman.co.uk/teaching
Programming Practice and Applications (4CCS1PPA)
Topic 9: Combining Objects
Q: So far in the course, how have we combined objects? 1
Thursday 1st December 2016

Preface: Has-A Relationships
2

So far, we’ve already seen one technique we can use to
combine objects in order to model entities:
• We declare a ﬁeld in a class (Class A) to be of another
class type (Class B), and then store objects of Class B in
Class A.
• Objects of Class A use objects of Class B to deﬁne parts
of their own functionality.
• Consider an Aeroplane object that uses a
Coordinates object to store its position.
COMBINING OBJECTS: ASSOCIATION RELATIONSHIPS (1)
3

public class Aeroplane {
private String name;
private Coordinates coordinates;
private int speed;
private int totalDistance;
private int repairDistance;
public Aeroplane(String name, Coordinates coordinates,
int speed, int totalDistance, int repairDistance) {
this.name = name;
this.coordinates = coordinates;
this.speed = speed;
this.totalDistance = totalDistance;
this.repairDistance = repairDistance;
}
COMBINING OBJECTS: ASSOCIATION RELATIONSHIPS (2)
4
We say that an
Aeroplane is associated
with a pair of
Coordinates.

REPRESENTING ASSOCIATION RELATIONSHIPS IN CLASS DIAGRAMS (1)
5
You were not expected to include this relationship in your
documentation to date, as we hadn’t yet covered it during the lectures.

To represent an association relationship in a class diagram, we draw a
solid line from Class A (the class using objects of Class B as a part of its
own representation) to Class B.
• Until now we have only used dashed lines to represent a subset of
dependency: when Class A makes an object of Class B.
On this line, we place two numbers, to represent multiplicity.
• The first number represents the lower bound (the least number of
objects of Class B there can be stored in Class A).
• The second number (following the three dots) represents the upper
bound (the maximum number number of Class B objects there can be
in Class A).
• Naturally therefore, this will always be 0…1 unless a field represents a
list of objects (here a * represents no fixed upper bound).
REPRESENTING ASSOCIATION RELATIONSHIPS IN CLASS DIAGRAMS (2)
6

Association relationships often imply that objects are
combined by passing one object into another, perhaps from
a driving class.
• For example, in CW2, we created our Dishes in
CalorieTracker, and passed them to a Meal object.
OBJECT OWNERSHIP (1)
7
• This gave us the ﬂexibility to use the same Dish in
different Meals.
Dish toast = new Dish();
toast.setCalories(140);
Meal omeletteBreakfast = new Meal();
omeletteBreakfast.setStarter(toast);

😴
That’s because, at our current level of abstraction, the rule
is slightly different for objects.
When an object is passed to a method, any interactions with
that object will alter the original object.
• Reassigning the variable holding the class copy,
however, will not alter the object.
Next semester, when we look at objects in memory (i.e. a
lower level of abstraction), the reasoning behind this should
become clearer.
REMEMBER: OBJECTS IN MEMORY (3)
8

Because manipulating an object in one place in your
program affects all other uses of that object, implementing
an associative relationship may result in unexpected
behaviour:
OBJECT OWNERSHIP (2)
9
Coordinates destination1Coordinates = new Coordinates(110,
135);
Destination destination1 = new Destination("Buenos Aires",
destination1Coordinates);
Aeroplane plane = new Aeroplane("Spirit",
destination1Coordinates, 12, 0, 2550);
Here, when the plane ﬂies, so will Buenos Aires!

Instead, sometimes we want instances of Class A to own all the
instances that is uses of Class B. This avoids the danger of global
updates.
• All the instances of Class B that are used by Class A only exist
within instances of Class A.
• This is referred to as a composition relationship.
OBJECT OWNERSHIP (3): COMPOSITION
10
public class Aeroplane {
...
private Coordinates coordinates;
...
public Aeroplane(..., int x, int y, ...) {
...
this.coordinates = new Coordinates(x, y);
...
}

REPRESENTING COMPOSITION RELATIONSHIPS IN CLASS DIAGRAMS
11
You were not expected to include this relationship in your
documentation to date, as we hadn’t yet covered it during the lectures.
We place a ﬁlled
diamond next to the
class that owns
objects of the
connected class, to
differentiate
composition from
association.

We can generalise the idea of both association and
composition to the single idea of an object having an
instance of another.
• We call these HAS-A relationships.
HAS-A RELATIONSHIPS
12

In this topic, to complement HAS-A relationships, we will look
at another way to combine objects, or for one class to deﬁne
part of its functionality via another:
• Inheriting from a class such that (an object of) one class
IS-A (object of an)other class.
• Specialising the inherited class, for a new purpose.
We will also:
• Compare IS-A and HAS-A relationships.
• Discuss the different forms of IS-A relationships.
Students often ﬁnd this the hardest topic in PPA.
OBJECTIVES: COMBINING OBJECTS
13

Modelling A Medieval Village
14

Let’s imagine a medieval village that has a number of
villagers, who have the capability to ﬁght in order to defend
their village from attacks by trolls, and how we might model
this.
A MEDIEVAL VILLAGE
15

A VILLAGER: IN CODE
17
A villager has a name,
and an attack.
However, weedy villagers
can’t attack too well, so
there is no damage value
associated with this
attack.
Instead, we represent this
by simply returning a
string.
public class Villager {
public Villager(String name) {
this.name = name;
}
public String getAttack() {
return name + " throws a punch";
}
public String getName() {
return name;
}
}

A SWORDSMAN: IN CODE (FIRST PASS)
19
A swordsman is just
another type of villager,
except an armed one, but
they too are ineffective.
Because a class’s identity is
deﬁned by its interface (i.e.
its public methods), we
might choose to represent
this by creating a class with
the same interface.
But really, we should try
and avoid this repetition,
as it makes our code
difﬁcult to maintain. What
are our options?
public class Swordsman {
public Swordsman(String name) {
this.name = name;
}
return name + " swings a sword";
}
return name;
}
}

Recall in CW4 we saw that an exam can play two different
roles (as a mark scheme or as an exam attempt).
FLEXIBLE OBJECTS (1)
20
Can we apply the same idea here to avoid writing a second
class?
Exam markScheme = new Exam(nqMarkScheme, bqMarkScheme, mcqMarkScheme, 7);
Exam examAttempt = new Exam(nqAttempt, bqAttempt, mcqAttempt, 0);
public class Village {
public static void main(String[] args) {
Villager villager = new Villager("Villager");
Villager swordsman = new Villager("Swordsman");
}
}

Whereas an exam could easily represent either a mark scheme or
a student script because both the interface and the functionality
behind the interface are the same, the swordsman’s functionality
differs slightly, so using the same class is difﬁcult:
FLEXIBLE OBJECTS (2)
21
What we really want is for Villager and Swordsman to share the
same interface but vary the functionality behind that interface.
}
Villager.java
return name + " swings a sword";
}
Swordsman.java

AWKWARD HAS-A RELATIONSHIPS (1)
22
private Villager villager;
this.villager = new Villager(name);
}
return villager.getName() + " swings a sword";
}
return villager.getName();
}
}
We could, if we
wanted to, use a
HAS-A relationship in
an attempt to alter
the functionality
behind the interface,
while minimising
repetition.
We delegate the task
of storing and
retrieving the name
to the existing
functionality in the
Villager object,
while adding to the
functionality.
Composition makes sense here to
retain unique individuals.

While the use of a HAS-A relationship here allows us to alter the
functionality behind the interface, we still have duplicate methods
in each class that perform the same functionality (e.g. getName).
Part of this issue comes from the fact that with a HAS-A
relationship we are only able to express when things own other
things not when they are other things, and thus share a common
interface.
• A Swordsman IS-A Villager it does not have (HAS-A) villager
(like Aeroplane’s have Coordinates), which is also awkward
conceptually.
In other words, we want our two classes to literally share the
same interface.
How do we do this?
AWKWARD HAS-A RELATIONSHIPS (2)
23

🤓
this.name = name;
}
}
return name;
}
}
CLASS INHERITANCE (1)
24
public class Swordsman extends Villager {
super(name);
}
return getName() + " swings a sword";
}
}

🤓
One class inherits (copies) all of the code from another, thus
assuming the same interface.
Because a class’s interface determines its identity, the
inheriting class is now also considered to be of the same
type as the class it inherits from.
• We therefore achieve our desired IS-A relationship.
25

26
Swordsman swordsman = new Swordsman("Swordsman");
System.out.println(swordsman.getName());
}
}
Although the getName method doesn’t exist in
Swordsman, we can still call it, because a Swordsman is
now also a Villager, and thus has the same interface
(the same public methods), and the associated ﬁelds in
which to store data.

🤓
Moreover, while retaining this interface, the inheriting class
can specialise the behaviour behind the interface.
• We can redeﬁne the behaviour in each method.
The inheriting class can also add to the interface.
27
Let’s examine the notion of class inheritance in more detail.
Villager Swordsman
The inheriting class
thus shares at least
the same interface as
the class it inherits.

We use the keywords extends to indicate that one class
inherits (copies) from another.
• We call the class that does the extending (e.g.
Swordsman) the subclass (or the child class) and the
class that is extended from the superclass (e.g.
Villager; the parent class).
• It is the act of extension that causes the subclass to
inherit (copy) everything from the superclass.
THE EXTENDS KEYWORD (1)
28
public class Swordsman extends Villager {

In order to indicate that one class inherits
from another in a class diagram, we draw
an arrow from the subclass to the
superclass, with an empty arrowhead.
INDICATING INHERITANCE IN A CLASS DIAGRAM
29

public class Father {
public int getActingSkill() {
return 8;
}
}
CONCEPTUAL INHERITANCE
30
This states that children are their parents (which is typically
true in terms of physical traits), but also that children tend to
redeﬁne their parent’s behaviours.
public class Son extends Father {
return 3;
}
}
Like most of the concepts in object-oriented programming the
concept of inheritance is linked to the real world.

🤓
}
Villager.java
OVERRIDING METHODS
31
}
Swordsman.java
Like the conceptual child redeﬁning the behaviour of a parent, when a
subclass extends a superclass, it can change the behaviour of the acquired
methods by using the same method signature (name and parameters).
• This allows us to specialise existing code for new purposes, while
also reusing other existing code.
• It also constrains us to use the relevant access modiﬁer and return
type (more later).

this.name = name;
}
}
return name;
}
}
We’ve seen that when we
extend a class we inherit all
the code from that class.
When we inherit from a
class, identiﬁers that are
private in the superclass,
such as name, remain private
from outside objects of the
subclass, which is intuitive.
THE EXTENDS KEYWORD (2): WHAT CAN WE ACCESS (1)
32

this.name = name;
}
}
return name;
}
}
Slightly less intuitively,
identiﬁers that are private in
the superclass, also cannot
be accessed from the
subclass.
• Parents keep things
private from their
children.
• Therefore, they are
effectively not
inherited.
33

}
Swordsman.java
Because private ﬁelds aren’t accessible in a subclass, we
cannot reference them directly in the subclass, but we can
call (public) methods from the superclass as if they were in
the same class, as they have been inherited.
• This allows us to access values that have been placed
into these private ﬁelds in the superclass from the
subclass, such as the values passed to the superclass
constructor, which we look at now:
34
From
Villager

Among the identifiers inherited from a superclass is that superclass’s
constructor(s).
• To construct a subclass, you must first call at least one of the
constructor(s) of the superclass.
• We shouldn’t lose the restrictions put in place by the superclass, as
they likely relate to inherited identifiers. For example, here,
Villager inherits getName, which relies on a value being present in
the name field.
• This is done by the subclass’s constructor.
THE SUPER KEYWORD (PART 1) (1)
35
super(name);
}
this.name = name;
}

Remember multiple constructors give us different patterns we can
match when we create an object of a class.
REMEMBER: LECTURE EXERCISE: BOOK (9), ADDITIONAL CONSTRUCTOR
36
private int currentPage;
private int totalPages;
public Book(int totalPages) {
currentPage = 1;
this.totalPages = totalPages;
}
public Book() {
currentPage = 1;
totalPages = 0;
}
this(0);

• To differentiate between the identiﬁers that exist in the subclass,
and those that come from the superclass we use the keyword super.
• Like writing this (with parameters) to call a constructor in the
same class, we simply write super (with parameters) to call a
constructor in the superclass.
• If the superclass has an empty or default constructor, a super call
will be added implicitly.
• This sets up the parent class.
THE SUPER KEYWORD (PART 1) (2)
37
super(name);
}
this.name = name;
}

Sometimes it might be useful to access the information returned
from a method before it is overridden.
As with the constructor, we use the keyword super to differentiate
between the method in the superclass, and the method in the
subclass.
• However this time we use it almost like a special object, that
references the superclass, and after which we place a dot.
ACCESSING ORIGINAL METHODS (THE SUPER KEYWORD (PART 2))
38
public class Father {
return 8;
}
}
public class Son extends Father {
return super.getActingSkill() / 2.0;
}
}
We might imagine the a son is only
ever half as good an actor as their
father.

We can’t override fields from the parent class in the same way.
• If they are private, they aren’t accessible anyway.
• If they happened to be public, they will be accessible,
and fields of the same name in the subclass will hide the
field inherited from the superclass.
• However, as public fields should also be final and
static, they should be accessed directly through the
class anyway, negating this issue.
• If they must be accessed through the instance, then
the super keyword can be used to differentiate, as it
can with methods.
ASIDE: OVERRIDING FIELDS?
39

It hopefully makes intuitive sense that ﬁnal classes cannot
be extended.
Therefore, it also hopefully makes intuitive sense that ﬁnal
methods cannot be overridden.
We might see this as yet another way that object-orientation
allows us to control how our code is used.
• We saw other ways in which object-orientation allows
us to control how our code is used in Topic 4.
ASIDE: THE IMPACT OF FINAL ON INHERITANCE
40
public final class Father {

LECTURE EXERCISE: EXAMS AND MARK SCHEMES
41
public class BooleanQuestion {
private boolean answer;
private int mark;
public BooleanQuestion(boolean answer, int mark) {
this.answer = answer;
this.mark = mark;
}
public boolean lookAtAnswer() {
return answer;
}
public class NumericalQuestion {
private int answer;
private int mark;
public NumericalQuestion(int answer, int mark) {
this.answer = answer;
this.mark = mark;
}
public int lookAtAnswer() {
return answer;
}

The next few slides are tough, stay with me…
42

Because a subclass is the same type as its superclass, we
can legally do the following:
POLYMORPHISM (1)
43
This provides us with important ﬂexibility when
representing a set of villagers in our village:
Villager swordsman = new Swordsman("Swordsman");

BACK TO THE MEDIEVAL VILLAGE (FIRST PASS)
44
ArrayList<Villager> villagers = new ArrayList<Villager>();
System.out.println("Who is in the village?");
for ( int i = 0; i < Integer.parseInt(args[0]); i++ ) {
int selection = ((int)(Math.random() * 2));
if ( selection == 0 ) {
villagers.add(new Villager("Villager"));
} else {
villagers.add(new Swordsman("Swordsman"));
}
}
Based on a
command line
argument (N), create
N villagers of a
random type.

We’ve seen that both arrays and arraylists can only store values
of the same type.
It might therefore seem strange that I can add villagers and
swordsmen to an arraylist that is typed as a Villager.
But recall that this homogenous restriction is in place in the
ﬁrst place to ensure that all elements in the list act in the same
way.
Because Swordsman and Villager now share a common
interface via inheritance (a swordsman IS-A villager), a
swordsman will behave in at least the same way as a villager,
so can be stored in the same list.
INHERITANCE AND TYPES
45
ArrayList<Villager> villagers = new ArrayList<Villager>();
villagers.add(new Swordsman("Swordsman"));

🤓
As well as the above, the following is still possible:
POLYMORPHISM (2)
46
This means we could end up in a situation in which in the
same program, two variables of the same type (the same
interface; Villager) present different behaviour.

🤓
This is known as polymorphism.
• Sometimes a Villager takes the form of itself, sometimes of
its child class Swordsman (it has many (poly) forms (morph)).
• Because method overriding facilitates this difference in
behaviour, the two terms are often used interchangeably.
This ﬂexibility is useful for our ﬁght:
POLYMORPHISM (3)
47
Same interface Different form

🤓
We can iterate through this list, and call any method in the
parent type.
• If it has been overridden, we will call the overridden
method instead.
• So our villagers ﬁght in their own ways, as desired.
THE VILLAGE (FIRST PASS): POLYMORPHISM (AND FIGHTING TROLLS) (1)
48
Continued in
the main
method of
Village:
System.out.println("A troll attacks the village");
for ( Villager villager : villagers ) {
System.out.println(villager.getAttack());
} Village.java

🤓
We can iterate through this list, and call any method in the parent
type.
• We are still interacting with the same Villager interface each
time but the behaviour behind that interface is different
depending on the actual type of each object in the arraylist.
• But we still reach the new behaviour through the Villager
interface. This has implications (more later).
THE VILLAGE (FIRST PASS): POLYMORPHISM (AND FIGHTING TROLLS) (2)
49
}
Continued in
the main
method of
Village:
Village.java

Can a Villager also be a Swordsman?
No. Because we can add to the interface of the subclass without
changing the interface of the superclass, we cannot guarantee
that the entire interface of Swordsman will be supported by the
Villager object.
ASIDE: SUPERCLASS AS A SUBCLASS?
50
Swordsman anotherSwordsman = new Villager("Another Swordsman");
Villager Swordsman
Villagers and
Swordsman share a
common interface, but
this doesn’t mean that
the Swordsman cannot
add to this interface
(more shortly).

🤓
POLYMORPHISM (METHODS AND RETURN TYPES) (1)
51
private ArrayList<Villager> villagers;
public Village() {
villagers = new ArrayList<Villager>();
}
public void addVillager(Villager villager) {
villagers.add(villager);
}
public void addRandomVillager() {
villagers.add(randomVillager());
}
We can tighten up our representation
of a village:
It’s not only lists
that are
polymorphic,
parameters and
return types can be
too.
Any type of Villager
can be added to a
Village.

🤓
52
public String fight(Villager villager) {
return villager.getAttack();
}
public void allFight() {
System.out.println(fight(villager));
}
}
Any villager
is made to
attack.
that are
polymorphic,
parameters and
return types can be
too.
Village.java

🤓
53
public Villager randomVillager() {
return new Villager("Villager");
} else {
return new Swordsman("Swordsman");
}
}
}
Any type of villager
can be returned from
this method.
that are
polymorphic,
parameters and
return types can be
too.
Village.java

TROLL FIGHT (PART 1)
54
public class TrollFight {
Village village = new Village();
village.addRandomVillager();
}
village.allFight();
}
}
We’ll return to our troll ﬁght later.

🤓
This flexibility offer by polymorphism makes our programs
very easy to reuse and extend.
• Someone else can make a Village object, and create a
new type of villager (e.g a bowman) that can then
added to the village, and made to fight, without further
modification.
This is an idea we can also see more practically in the Java
library, along with the notions of inheritance and overriding.
POLYMORPHISM (REUSABILITY)
55

Inheritance And The Java Library
56

We’ve already been using inheritance, and
indeed overriding methods, in our programs
(probably) without realising it.
All classes implicitly inherit from a Java
library class called Object.
• As all subclasses must call at least one
constructor of their parent class,
implicit super calls are added to each
of our classes to the constructor of
Object.
We should see some methods here that are
familiar to us.
OBJECT
57

😴
REMEMBER: THE TOSTRING() METHOD (2)
58
public String toString() {
return "(" + x + "," + y + ")";
}
In the
coordinates
class:
Coordinates planeCoordinates = new Coordinates(10, 30);
System.out.println(planeCoordinates);
In a driving class:
You cannot supply
any parameters.
You must return
a String.

The most familiar of the methods in the Object
class is (probably) toString.
Now it should be clearer why the JVM looks for
a toString method in order to print a string
representation of an object: because it knows
that all objects have (inherit) this method.
When we write our own toString method we
override the default functionality (by keeping
the same name and parameters, and not
altering the return type), such that the JVM still
looks for the toString method, but instead
now uses our implementation.
• The default implementation of toString
inside Object is to return the name of the
current class, and a memory location.
TOSTRING
59

Another familiar method here should be
equals.
Let’s look at where we’ve seen this used
before, and what we can now understand
about its use given our knowledge of
inheritance and overriding.
EQUALS
60

In order to confirm that the JVM is sharing copies between
our variables, we can use the familiar comparison operator.
• This will print true.
REMEMBER: BACK TO COPYING STRINGS: ASKING ABOUT COPIES
61
String a = "A";
String b = "A";
String c = "A";
String d = "A";
}
System.out.println(a == b);
We ask the JVM, àre you sharing the
same string copy between a and b’?
Are a and b equivalent in memory?
This answer one of our open questions
about the flexibility of relational
operators.

😴
We use the .equals method in the String class* to compare
strings.
REMEMBER: COMPARING STRINGS (4)
62
String martin = "martin";
String mart = "mart";
String in = "in";
System.out.println(mart + in);
System.out.println(martin);
System.out.println(martin == mart + in);
System.out.println(martin.equals(mart + in));
}
*it actually exists elsewhere, more to come.

🤓
Because Strings are objects, then the way in which objects are
compared more generally should be similar to the way in which we
compare Strings.
• We don’t usually want to rely on object identity (==) to determine
if two objects are equal, even though in some cases this may
return a correct result.
• Like Strings, two objects may have similar values in their ﬁelds,
and thus be considered equal, but be held separately in memory.
• Instead, if we want to compare objects of our own classes, we
should override the equals method (which is exactly what the
String class does) to do this.
• The default behaviour of equals is to simply compare object
identity (==).
COMPARING OBJECTS (1)
63

EXAMPLE: COMPARING COORDINATES (1)
64
Coordinates destination1Coordinates = new Coordinates(110, 135);
Aeroplane plane = new Aeroplane("Spirit", destination1Coordinates,
12, 0, 2550);
System.out.println(destination1.getCoordinates() ==
plane.getCoordinates());
Aeroplane plane = new Aeroplane("Spirit", planeCoordinates,
12, 0, 2550);
System.out.println(destination1.getCoordinates() ==
plane.getCoordinates());
Should really print true.
Prints true.

Like toString, we use the same method name and parameters,
while keeping the return type consistent to override the equals
method in our Coordinates class.
Here though, we see the limitations of specialisation: we can’t
change the signature, otherwise the method won’t be overridden,
and thus equals, which accepts an object as a parameter in the
Object class, can only ever accept an object.
What’s the solution?
EXAMPLE: COMPARING COORDINATES (2): IMPLEMENTING EQUALS (1)
65
public boolean equals(Object coordinates) {
}

TROLL FIGHT (PART 2)
66
public class TrollFight {
Village village = new Village();
village.addRandomVillager();
}
village.allFight();
}
}
Let’s answer this by looking at a more general
problem in our troll ﬁght.

BACK TO THE MEDIEVAL VILLAGE: MAGES
67

MAGES: IN CODE
68
Adding new fields and
new methods is also
part of the
specialisation process.
If we wish to do more
work in a subclass
constructor (e.g.
assigning new fields),
the call to the super
constructor must
come first.
public class Mage extends Villager {
private int damage;
public Mage(String name, int damage) {
super(name);
this.damage = damage;
}
return getName() + "
casts a spell with damage " + damage;
}
public int getDamage() {
return damage;
}
}

public Villager randomVillager() {
return new Villager("Villager");
} else if ( selection == 1 ){
return new Swordsman("Swordsman");
} else {
return new Mage("Mage",
((int)(Math.random() * 10) + 1));
}
}
}
Village.java
We can update our
randomVillager
method accordingly
to account for the
presence of a mage.
69
Mages are given random
damage between 1 and 10.

public boolean allFight() {
int totalDamage = 0;
totalDamage += villager.getDamage();
}
if ( totalDamage > 50) {
return true;
}
return false;
} Village.java
TROLL FIGHT (PART 2): WHAT CAN KILL A TROLL?
70
Remember that villagers
and swordsmen have little
effect in a ﬁght (against a
troll), which we represent
using simple print
statements.
Mages, however, have
damage, which does affect
the troll.
We can represent this by
collecting the total damage
done by all the mages in our
party (remember we select
villagers at random) and
seeing if it is enough to
defeat the troll (50).
There’s a
problem: this
code will not
compile.

🤓
ERROR: CANNOT FIND SYMBOL
71
...
totalDamage += villager.getDamage();
}
Remember that although the behaviour speciﬁed by each
object in the villagers list may be different, we are still only
interacting with the Villager interface, so anything that isn’t
in that Villager interface cannot be referenced.
This makes sense,
because getDamage
is a method unique
to a mage, not to a
villager.

TROLL FIGHT (PART 2): WHAT CAN KILL A TROLL?
72
The solution is to
temporarily force a villager
to behave as a mage, so
that we can interact with
the Mage interface, rather
than the Villager
interface.
We want to cast a Villager
type as a Mage type, which
works because (some)
villagers are also mages.
public boolean allFight() {
int totalDamage = 0;
totalDamage +=
((Mage)villager).getDamage();
}
if ( totalDamage > 50) {
return true;
}
return false;
}
Village.java

😴
REMEMBER: ASIDE: CASTING
73
Why `casting’? Because the same value is cast in different roles.

There’s a problem here though. Not all of our villagers are
mages. What happens if we try and cast an object that isn’t
of the Mage type as a mage?
THE DANGERS OF CASTING
74
Mage mage = ((Mage)swordsman);
We get an error. Therefore, we can be fairly sure that if we
try and perform this cast at runtime (i.e. when the compiler
cannot check exactly what is in the villagers array), we will
also get an error:

if ( villager instanceof Mage ) {
damage += ((Mage)villager).getDamage();
}
}
Village.java
We need a way to look past the Villager interface and test the
actual type of the object in the array to see if it is of the same
type that we wish to cast to.
We can do this using a new operator called instance of:
INSTANCE OF
75
This operator
takes an object as
its ﬁrst operand
and a type as its
second.

🤓
We can now apply the same thinking to our equals method
for coordinates.
We cast the parameter of type Object, which works because
we can cast a super type to a subtype, as we have seen, and
we do so safely using instance of.
So our functionality is as expected:
76
if ( !(coordinates instanceof Coordinates) ) return false;
return x == ((Coordinates)coordinates).x && y ==
((Coordinates)coordinates).y;
}

77
Aeroplane plane = new Aeroplane("Spirit", destination1Coordinates,
12, 0, 2550);
System.out.println(destination1.getCoordinates().equals(
plane.getCoordinates()));
Aeroplane plane = new Aeroplane("Spirit", planeCoordinates,
12, 0, 2550);
System.out.println(destination1.getCoordinates().equals(
plane.getCoordinates()));
Prints true.
Prints true.

The next few slides are also tough, stay with me…
78

A valid question here is, why override equals? Why not simply compare objects
using a method with a name of our own choosing or just using accessor
methods?
• In our Noughts and Crosses game, we simply used a method called matches.
Partly, it’s convention to use .equals to compare objects.
More subtly, remember the notion of polymorphic arguments.
• In our Villager class, we saw that no matter which type of Villager (one
that already exists, or a new type) is passed to the fight method, they can
have the method getAttack invoked on them.
• This is because all villagers have this method, overridden or not.
• We might think of fight as providing a reusable service — prompting a
villager to ﬁght (against a troll) — using a method provided in the Villager
class (getAttack).
SERVICE PROVIDERS (1)
79

🤓
REMEMBER: POLYMORPHISM (METHODS AND RETURN TYPES) (2)
80
}
public void allFight() {
}
}
Any villager
is made to
attack.
that are
polymorphic,
parameters and
return types can be
too.

To use this service (fight), we must pass an object that is capable of supporting
the task carried out by the service; an object that has a getAttack method; a
villager that can ﬁght.
• In other words we can only pass villagers, or their descendent classes.
• This makes the service exclusive. We will look at this idea in the ﬁnal
section of the topic.
This service only works in an expected way if the getAttack method is
overridden correctly.
• Otherwise the method from the superclass (Villager) will be called instead.
Moreover, this service only works in an expected way if something sensible is
returned from an overridden getAttack method.
• If, for example, the string `Run Away’ were returned, then the output would
not be as expected.
81

Many methods in library classes operate in the same way
• They accept a parameter of type Object.
• This means that no restrictions are placed on the
extension hierarchy of the objects passed to these
methods (the service is non-exclusive).
• Methods from the Object class can still be called on
any passed objects in order to achieve their advertised
service, because these methods exist in every object.
• If we want to use this service, and have it behave in a
way that we expect, we have to pass objects of our own
classes to it with methods overridden in a certain way.
82

The contains method in the ArrayList class operates in
this way, as a service provider.
The service it offers is to return you true if the ArrayList
contains the supplied object.
CONTAINS
83

To perform this service, the contains method relies on the existence
of the equals method (which is conﬁrmed).
But for the service to work as expected (i.e. for an object to be
correctly located in the list) the equals method must be overridden
correctly and implemented in a manner that allows for the correct
expression of object equality.
CONTAINS
84

Let’s understand how contains works for a list of coordinates,
and thus why overriding equals in our Coordinates object in
the correct way allows contains to successfully provide its
advertised service:
CONTAINS EXAMPLE: FINDING AN EQUAL COORDINATE (1)
85
Destination destination1 = new Destination("Buenos Aires", destination1Coordinates);
Destination destination2 = new Destination("Muscat", destination2Coordinates);
Destination destination3 = new Destination("Zanzibar", destination3Coordinates);
ArrayList<Coordinates> coordinates = new ArrayList<Coordinates>();
coordinates.add(destination3Coordinates);
Coordinates aeroplaneCoordinates = new Coordinates(110, 135);
System.out.println(coordinates.contains(aeroplaneCoordinates));

🙈
Coordinates aeroplaneCoordinates =
new Coordinates(110, 135);
if ( !(coordinates instanceof Coordinates) ) return false;
return x == ((Coordinates)coordinates).x && y ==
((Coordinates)coordinates).y;
}
110
135
86
ArrayList<Coordinates> coordinates
110525105 30 135
The contains method repeatedly calls equals on its object argument,
and each time passes each element of the list as an argument. If
equals returns true at any point, contains returns true:
X X

87
110525105 30 135
Without an adequately implemented equals method, or without
overriding equals properly, contains cannot fulﬁl its advertised service.
return true;
}
If we just returned true, contains would assume
that anything was contained in our list

88
110525105 30 135
Without an adequately implemented equals method, or without
overriding equals properly, contains cannot fulﬁl its advertised service.
public boolean equals(Coordinates coordinates) {
}
If we change the parameter type to Coordinate, we
aren’t really supplying a true equals method: it’s
just a method that happens to be called equals
(not the same signature), and contains uses the
default implementation of equals from Object.

Most of the time equals will work as expected under a simple
implementation, but you may wish to check the following in order to
ensure that equals always works (i.e. these are guidelines):
• Ensure equals is symmetric ("If I compare CoordinateA to
CoordinateB, and return true, do I also return true if I compare
CoordinateB to CoordinateA?")
• Ensure equals is reﬂexive ("If I compare CoordinateA to
CoordinateA, do I get a true value?").
• Implement a supplementary Hashcode method, but typically
only required if you intend to store your objects in hashed data
structures, which we have not looked at.
• Strict warnings about this from the compiler can thus be
ignored (like the lack of a close method when using Scanner).
ASIDE: SAFELY OVERRIDING EQUALS
89

Recall that, currently, the only accessible identifiers that are
inherited from a class are those marked public.
• Private identifiers remain private to the parent.
There is another modifier available to us that makes an identifier
accessible:
ASIDE: ACCESSIBLE IDENTIFIERS (1)
90
protected String name;
Protected identifiers are private to the class, and all subclasses
(technically).
In reality, given what we’ve seen so far, there’s no difference
between public, protected and fields without an access modifier
(more next semester).

Taking this technical definition of protected, I still tend to rely
on accessors in the subclass, and keep things private.
• If we send our class out into the world and someone
extends it, they could compromise encapsulation by
accessing protected fields directly from a subclass.
I’m more likely to use protected methods.
• Related aside: we haven’t looked at private methods
directly, but hopefully the result of using this access
modifier on a method is clear: that method can only be
accessed with the class itself.
• Private methods therefore support the functionality
offered by other methods.
ASIDE: ACCESSIBLE IDENTIFIERS (2)
91

😴
If we want to do this we can specify multiple constructors,
each of which accepts different parameters, thus giving a user
the option to construct an object of our class in different ways.
REMEMBER: ASIDE: RELINQUISHING CONTROL FOR FLEXIBILITY (2)
92
private double balance;
public BankAccount() {}
public BankAccount(double deposit) {
balance = deposit;
}
Each of our constructors has a
different pattern, and thus there are
different ways to match and create
objects of the class.
Open question: Why
is it ok for us to
break our `methods
with unique
names’ (Topic 3,
Slide 14) rule here?
Speciﬁcally, we use an empty
constructor. We can see this as replacing
the default constructor we had
previously, to remove any restrictions
from the creation of objects of our class.

We are familiar with the idea of having multiple constructors.
The reason this is possible is because methods are not just
differentiated by their name, but also their parameters (the whole
signature), as was alluded to in Topic 3.
This idea extends to any method, such that we can use the same name
for two methods, so long as the parameters in those method are
different:
ASIDE: METHOD OVERLOADING AS A FORM OF POLYMORPHISM (1)
93
public void addVillagerToParty(Villager villager) {
villagers.add(villager);
}
public void addVillagerToParty() {
villagers.add(randomVillager());
}
This neatens things up
if methods perform
broadly the same
functionality, except
rely on different input.

Because this is another example of (components of) the
same interface (i.e. the method name) taking different forms,
this is also often considered to be a form of polymorphism.
• But we will consider this a sub deﬁnition.
ASIDE: METHOD OVERLOADING AS A FORM OF POLYMORPHISM (1)
94
Access modiﬁers and return type cannot be used to
differentiate a method:
public void fight(Villager villager) {
}
} This code will not compile.

Given that access modiﬁer and return type are not enough
to differentiate a method, is it ok if we change them in the
subclass (i.e. the overridden method)?
ASIDE: REDUCING VISIBILITY IN THE INTERFACE (1)
95
Given that we now know what deﬁnes a method, it should be
even clearer now why overriding works: we replace that
method’s signature.
}
Villager.java
}
Swordsman.java
private

No, because polymorphism (the ability to interact with
object of a superclass and a subclass via a superclass
variable), relies on the shared interface (methods with the
same name and parameters) behaving in the same way.
• But we can change an overridden method to return a
subclass of a class type returned from a superclass
method, as the deﬁnition of the superclass is suitably
general.
ASIDE: REDUCING VISIBILITY IN THE INTERFACE (2)
96
public Object getAttack() {
}
Villager.java
Doing this the other way
round would not work, for
the reasons described.

😴
Given that we now know all classes
inherit from Object, it should be
clear that we can construct
hierarchies of classes, in which we
inherit from a class that already
inherits from another, and so on.
But you can only inherit from one
class directly. The reasons for this are
subtle, and will be presented next
term.
ASIDE: CLASS HIERARCHY
97

Hopefully it’s even
more clear now
why this HAS-A
relationship is
awkward.
We wouldn’t be
able to keep an
array of villagers
that also contains
swordsmen.
ASIDE: ARE HAS-A RELATIONSHIPS NOW USELESS? (1)
98
private Villager villager;
this.villager = new Villager(name);
}
return villager.getName() + " swings a sword";
}
return villager.getName();
}
}

Can we extend this idea, such that we just ditch the HAS-A
relationship and extend everything? Absolutely not. Would
the following make sense?
ASIDE: ARE HAS-A RELATIONSHIPS NOW USELESS? (2)
99
This is awkward conceptually, but also tying yourself into a
single class hierarchy, due to the fact that only one class can
be extended, is also limiting, as we will see in the ﬁnal
section of this topic.
public class Aeroplane extends Coordinates {
private int speed;
private int totalDistance;
private int repairDistance;
An aeroplane is
deﬁned as
much more
than a
coordinate.

Interfaces And Abstract Classes
100

Let’s think again about the notion of polymorphic
arguments enabling us to use the services of other classes.
• To use a service, so far we’ve seen that you have to
pass an object that extends a certain class.
• This is typically not an issue when class you are
expected to extend is Object (as this extension is done
by default), but in other circumstances it can be.
• Sometimes, to have to tie one of your classes to being
another class just to use a service is limiting.
TYING YOURSELF TO A SINGLE IS-A RELATIONSHIP
101

BACK TO THE VILLAGE… (1)
102

Let’s consider the introduction of our troll more ofﬁcially, as an
entity that can ﬁght with our villagers:
BACK TO THE VILLAGE… (2)
103
public class Troll {
private int hitPoints;
public Troll(int hitPoints) {
this.hitPoints = hitPoints;
}
public int getHitPoints() {
return hitPoints;
}
}
Troll troll = new Troll();
village.allFight(troll);
TrollFight.java
public boolean allFight(Troll troll) {
int damage = 0;
if ( villager instanceof Mage ) {
damage += ((Mage)villager).getDamage();
}
}
if ( damage >= troll.getHitPoints()) {
return true;
}
return false;
} Village.java

In addition to ﬁghting villagers, let’s imagine that there are two
other ways our troll can interact with a village:
THE FUN OF A TROLL (1)
104
public class Troll {
private String phrase;
private int bashRange, hitPoints;
public Troll(String phrase … ) {
this.phrase = phrase;
…
}
public String shout() {
return phrase;
}
public int getBashRange() { … }
public int getHitPoints() { … }
}
private int houses;
public Village() {
…
houses = 100;
}
public void intimidate(Troll troll) {
System.out.println(troll.shout());
}
public void destroy(Troll troll) {
houses -= troll.getBashRange();
}
Village.java
Troll troll = new Troll(
"Rawr! Pesky Villagers!", 10, 50);
TrollFight.java
services

Furthermore, let’s imagine that our troll is having so much
fun rampaging around the village, that he decides to invite
friends: a werewolf and a giant.
BRINGING FRIENDS (1)
105

Werewolves can intimidate with their howl, but are too small
to bash, and giants can bash, but they do not shout.
BRINGING FRIENDS (2)
106
public class Werewolf {
public Werewolf(String phrase, int hitPoints) {
}
return phrase;
}
return hitPoints;
}
}
public class Giant {
private int bashRange, hitPoints;
public Giant(int bashRange, int hitPoints) {
this.bashRange = bashRange;
}
public int getBashRange() {
return bashRange;
}
return hitPoints;
}
}

Because these two creatures can also ﬁght with the villagers, we
could create a common super class Enemy, and place hit point
information inside this class, such that Troll, Werewolf and
Giant all extend this class:
FIGHT ANYTHING
107
public class Enemy {
public Enemy(int hitPoints) {
}
return hitPoints;
}
}
public class Werewolf extends Enemy {
Werewolf.java
public class Giant extends Enemy {
Giant.java
public class Troll extends Enemy {
Troll.java
public boolean allFight(Enemy enemy) {
Villager.java
Then any enemy can ﬁght:

But what about the other behaviours: shout and bash?
• We can’t put this information in the Enemy class,
because only giants and trolls can bash, and only
werewolves and trolls can shout.
• We can’t only put bash in Giant and shout in
Werewolf, because Troll also needs this, and we don’t
want repeated code.
• We can’t leave everything in Troll, because then giants
and werewolves won’t have these behaviours.
SHOUTING AND BASHING (1)
108

A naïve choice might be to create two new classes, Shouter
and Basher:
109
public class Basher {
private int bashRange;
public Basher(int bashRange) {
}
return bashRange;
}
}
public class Shouter {
public Shouter(String phrase) {
}
return phrase;
}
}

110
We could then change the arguments to the action methods in
Village, in order to accept objects of this type:
And the werewolf and giant could switch up their inheritance to
instead be a shouter and a basher, respectively, in order to interact
with the village:
public class Werewolf extends Shouter {
public class Giant extends Basher {
public void intimidate(Shouter shouter) {
System.out.println(shouter.shout());
}
Village.java
public void destroy(Basher basher) {
houses -= basher.getBashRange();
}
Village.java
Services are now limited to
shouters and bashers.

There are two issues here:
• How do werewolf and giant now ﬁght (recall allFight accepts an
Enemy)? Shouter and Basher could extend Enemy (three tiers):
111
• But what if villagers want to shout? This would make them
enemies too. We have to have a logical inheritance hierarchy.
• What about our poor troll?
public boolean allFight(Enemy enemy) {
public class Shouter extends Enemy { public class Basher extends Enemy {
public class Troll extends {?

🤓
Our troll now how to make a decision: do I want to be shouter or a
basher (or an enemy)?
• The parameter types required by these methods (services) are
limiting in that you have to tie a class into a whole existence in
order for it to use these methods.
• The troll could tie himself to being a shouter, but then he also
can’t be be a basher (or an enemy) and thus can’t destroy, and
vice-versa.
• That is, only one class can be extended.
But he wants to do everything! What’s the solution?
GIVING THE TROLL WHAT HE WANTS
112
}
Village.java
}
Village.java

Let’s think about our options:
• Option 1: Stick to a HAS-A relationship?
• Option 2: We need some way to be able to say that a Troll
IS-A Shouter and that a Troll IS-A Basher, so that he can
both intimidate and destroy (i.e. use these services),
without the dangers of multiple inheritance.
• Option 3: We want the methods (services) intimidate and
destroy not to force our Troll (or any of the other
creatures) to extend only Shouter or Basher in order to use
them, but still be certain that the methods they need in
order to operate will be available in any object arguments.
LAYING OUT OUR OPTIONS…
113

HAS-A RELATIONSHIPS TO THE RESCUE? (1)
114
Partially, yes, because by delegating actions inside Troll to either a
Shouter or Basher object (while potentially inheriting from the other),
we can exploit the functionality offered by two classes.
We implied before that
HAS-A relationships might
be of use here.
Can they save us in this
case?
In many cases, we prefer
delegation to inheritance
to avoid having to sacriﬁce
our single extends for a
small piece of
functionality.
public class Troll extends Basher {
private Shouter shouter;
public Troll(int bashRange, String phrase) {
super(bashRange);
shouter = new Shouter(phrase);
}
return shouter.shout();
}

We implied before that
HAS-A relationships might
be of use here.
Can they save us in this
case?
In many cases, we prefer
delegation to inheritance
to avoid having to sacriﬁce
our single extends for a
small piece of
functionality.
HAS-A RELATIONSHIPS TO THE RESCUE? (2)
115
But, in this case, the troll still cannot use the services offered by both
intimidate and destroy because it is still only one of these things (it
bashes like a troll but doesn’t shout like a troll).
private Shouter shouter;
public Troll(int bashRange, String phrase) {
super(bashRange);
shouter = new Shouter(phrase);
}
return shouter.shout();
}
This also
doesn’t read
particularly
well.

😴
What’s holding us back
from extending two
classes (Option 2)?
Multiple inheritance can
lead to ambiguities, if
two methods exist in
different superclasses
with the same name
and different
functionality (more
detailed explanation
next term).
THE PROBLEM WITH MULTIPLE INHERITANCE: IN SHORT
116
Which version of burn does
ComboDrive get?

🤓
One class inherits (copies) all of the code from another, thus
assuming the same interface.
Because a class’s interface determines its identity, the
inheriting class is now also considered to be of the same
type as the class it inherits from.
• We therefore achieve our desired IS-A relationship.
REMEMBER: CLASS INHERITANCE (2)
117

🤓
EMPTY METHODS? (1)
118
What if all the classes we inherited from didn’t have any code
in their methods?
We wouldn’t be able to reuse any functionality, but this would
allow us to avoid the inheritance ambiguity listed on Slide 116,
because we would always add functionality in the child class
via overriding.
public int getBashRange(){}
}
public String shout(){}
}

🤓
EMPTY METHODS? (2)
119
Instead, all that would be inherited would be the signatures of
the methods, plus their return type and access modiﬁer (i.e.
the class interface) but this would be ﬁne as this is enough for
a class to share the identity of another class, and thus be
another class.
}
}

EMPTY METHODS? (3)
120
In other words, this would still allow us to express (both
formally and conceptually) that one class IS-A(nother) class:
Moreover, there would now be no argument against multiple
inheritance (Option 2):
public class Troll extends Shouter, Basher {
Although this won’t yet compile.
}
}

🤓
Because, when a class is empty in this way, all that would be
inherited from that class would be its interface, we signify this
to Java formally by calling a class with empty methods an…
interface.
• Note the ability to place semi-colons after methods, which
we cannot do in a normal class.
In addition, classes implement interfaces, rather than extending
them:
IMPLEMENTING AN INTERFACE (1)
121
public class Troll implements Shouter, Basher {
public interface Basher {
public int getBashRange();
}
public interface Shouter {
public String shout();
}

🤓
In the previous slide we used the word interface in two different ways:
• To conceptually refer to the public facing functionality of a class;
the methods it exposes; what a user of that class interacts with.
• To refer to a type of class that has the sole purpose of permitting
another class to be its type in a non-limiting way (i.e. the
implementing class can also implement other interfaces; be
other things but not function like other things), by presenting
just the interface of a class.
Hopefully the relationship between these two ideas is clear.
And hopefully it’s clear that this has nothing to do with graphical user
interfaces.
ASIDE: INTERFACE VS. INTERFACE
122

🤓
Why do we need to formally indicate to Java that a class is
being used as an interface?
Because there are then rules for the form of this class.
INTERFACES: RULES
123
}
}

The most natural rule, if a class is an interface, is that its methods
must be empty.
• If methods are not empty, the interface won’t compile, to
avoid functionality conﬂict.
Caveat: This restriction was lifted in Java 8 in favour of marking
methods in an interface with default functionality as default in
order to identify potential function ambiguity in advance. I ﬁnd
this both conceptually awkward, and more likely to introduce
compiler errors, so I would recommend omitting default
functionality from your interfaces.
INTERFACES: RULE 1 - EMPTY METHODS
124
}
}

Because interfaces don’t contain any functionality, it doesn’t
make sense for Java to permit objects to be made of these
classes.
• Therefore interfaces can't include constructors or
anything else that is associated with making instances
of classes.
INTERFACES: RULE 2 - NO OBJECTS
125
}
}

Everything in the interface has to be public.
• Accessible (public) methods define the (conceptual) interface of a
class, which is all that is provided to implementing classes, so it
wouldn’t make sense to permit private methods.
State cannot be represented in an interface, but can be added by an
implementing class.
• (Public) fields are permitted, but values must be assigned on the
field because they are static by default (as you cannot make
instances of an interface) and thus final (to avoid global updates) by
default. Used to define constants (contentious).
INTERFACES: RULES 3 AND 4 - PUBLIC AND FIELDS
126
}
}

In addition, when we mark a class as an interface and a class
implements that interface, the methods themselves are not
actually inherited (copied).
Instead what is inherited is an obligation for the
implementing class to add these methods. If it does not, then
the code will not compile.
• Functionality is still added to these methods in the
implementing class, negating any issue with two
interface methods sharing the same signature.
INTERFACES: RULE 5 - METHOD IMPLEMENTATION
127
}
}

🤓
Here we are saying that a Troll
IS-A Shouter and IS-A Basher
so it has to behave like it.
• What are the beneﬁts of
this?
128
}
}
public Troll(String phrase, int bashRange) {
}
return phrase;
}
return bashRange;
}
}
If Troll did not re-implement
shout and getBashRange, this
class would not compile.
To implement a
method from an
interface you do so
in the same way as
overriding a
method from a
superclass.

The intimidate and destroy methods now have the option to
accept objects that implement an interface, rather than
extend a class, and to thus be non-exclusive (Option 3).
• To use these services, a class only has to implement an
interface, not tie itself into an entire hierarchy, and a
class can implement as many interfaces as it likes.
At the same time, these methods know that only an object that
implements the interface type (e.g. Shouter and Basher), can be
passed as an argument.
NON-EXCLUSIVE SERVICE PROVIDERS (1)
129
}
Village.java
}
Village.java

NON-EXCLUSIVE SERVICE PROVIDERS (2)
130
As we know, an object that implements an interface must implement
all the methods from that interface.
Thus, like traditional polymorphic arguments, these methods can
call methods on the passed object from the interface type (e.g.
shout and getBashRange) in order to achieve their advertised
service, and be sure that those methods will exist.
• Intimidate and shout would not be able to have this assurance
if interfaces did not ensure the existence of their methods in
implementing classes.
• But of course, appropriate functionality is still not guaranteed.
}
Village.java
}
Village.java

And now the troll is free
to intimidate and bash
as he pleases, along with
his friends, should they
wish to:
131
public Troll(String phrase, int bashRange) {
}
return phrase;
}
return bashRange;
}
}
}
Village.java
}
Village.java
public class Werewolf implements Shouter {
public class Giant implements Basher {

ASIDE: EXTENDS AND IMPLEMENTS
132
As a ﬁnal optimisation, Troll (and Werewolf and Giant) could
still extend Enemy, and thus ﬁght with villagers, while also
shouting and bashing:
public class Troll extends Enemy implements Shouter, Basher {
If Enemy were to have a method (Method A) with the same
signature as a method in either the Shouter or Basher
interfaces (Method B), Method A would be considered the
implementation of Method B, and thus issues with functionality
ambiguity are still avoided.

Are interfaces now preferable to normal classes?
• For example, should our methods now only accept interfaces for
maximum ﬂexibility?
Base classes (that can be extended) and interfaces play different roles:
• Interfaces present abstract behaviours; capabilities; things that can
be done (e.g. shouting and bashing), not the functionality supporting
that behaviour; base classes deﬁne a single existence, and thus both
behaviour and functionality which can be copied.
• This tradeoff allows for classes to be multiple things (i.e.
implement multiple interfaces), and thus use multiple services, at
the cost of not being able to reuse functionality.
IMPLEMENTING AN INTERFACE VS. EXTENDING A BASE CLASS (1)
133

Trolls, villagers and Martin playing on his Playstation too
much is all very well, but what about a more practical
example of the use of interfaces and services?
Some library classes that provide services don’t want to
force one of our classes to inherit a single other class in
order to use their service. Therefore, they instead accept
objects of an interface type.
A MORE PRACTICAL EXAMPLE?
134

A TreeMap provides us with a service: it will sort any
<key,value> pairs we add by key.
But to do so, we have to offer that service a method (a
behaviour) that enables it to sort our keys.
TreeMap quantiﬁes this request by forcing any supplied keys to
be comparable, but retains the ﬂexibility for keys to extend
other classes by accepting keys that implement the
Comparable interface.
We have seen what happens if we do not adhere to this
restriction:
TREEMAP
135
private TreeMap<String, Integer> customerTotalSpend;

ERROR: CLASS CAST EXCEPTION AND COMPARABLE
136
Strings implement the Comparable interface by default
but Customer (one of our own classes) does not, hence
this error.
Our Customer class will not be able to correctly support
the service offered by the TreeMap class (i.e. customers
cannot be compared), and the TreeMap class knows this.
private TreeMap<Customer, Integer> customerTotalSpend;

COMPARABLE
137
Comparable is an interface that ensures implementing classes
supply a single method that returns an integer to indicate whether
a compared object should be positioned before or after the current
one when being sorted.
Other classes, such as TreeMap,
call compareTo in order to achieve
their service, in the same way that
contains calls equals.
This is how something should behave
if it wants to be comparable.

Like a Troll that must shout if it wants to be a Shouter (and
intimidate a village) and provide a bashRange if it wants to
be a Basher (and destroy a village), a Customer must provide
a compareTo method if is to be Comparable (and sorted in a
TreeMap (or other places)):
IMPLEMENTING COMPARABLE (1)
138
public class Customer implements Comparable<Customer> {
public int compareTo(Customer o) {
} Customer.java

You will have noticed that we were able to type the Comparable
interface in the previous example in the same way that we can
type lists, using the diamond notation.
Doing this effectively alters the form of the compareTo method
in the Comparable interface to include a parameter of our own
Customer type, thus we can implement (override) this method
without having to check the instance of the parameter, or cast it:
ASIDE: GENERIC INTERFACES
139
We didn’t have the same ﬂexibility when overriding equals through
inheritance, and it would be cumbersome to type object anyway.

In the case of our customer, we don’t need to do too much
work in our compareTo method, as there’s only really one
ﬁeld upon which we can base our comparisons: name, which
is a string.
Therefore, we can pass on the task of comparison to the
String class:
IMPLEMENTING COMPARABLE (2)
140
return name.compareTo(o.name);
} Customer.java
Customers are now Comparable, so TreeMap knows our
Customer class can support the service it offers.

THE SERVICE PROVIDED BY TREEMAP
141
shop.addProduct(diamond);
shop.addProduct(crownJewels);
shop.addProduct(silverLocket);
Customer martin = new Customer("Chapbeard");
Customer tomas = new Customer("Tomas");
Customer asad = new Customer("Asad");
shop.updateTotalSpend(martin, 100);
shop.updateTotalSpend(tomas, 100);
shop.updateTotalSpend(asad, 100);
System.out.println(shop.getCustomerTotalSpend());

Some more differences between implementing an interface
compared to extending a base class:
• It can be difﬁcult to modify an interface as all
implementing classes have to change too; it can be
easier to modify a base class, as the implementation
restrictions aren’t explicit.
• The behaviours expressed in an interface pertain to
those behaviours that are likely to span multiple
inheritance hierarchies (consider a Villager and a
Enemy, both of which are likely to shout); the behaviour
expressed in a class are only shared by those classes
within that hierarchy.
142

Some more differences between implementing an interface
compared to extending a base class:
• To use of an interface type can support the ﬂexibility of
a program by allowing the programmer to change the
underlying implementation of entities such as data
structures; base classes do not offer this support as
explicitly (because you can make and store an object of
the base class).
• Interface behaviours vary with each implementation
(e.g. things all shout in different ways); behaviours in a
base class are likely to be shared between
implementations (e.g. having and setting a name).
143

REMEMBER: TOPIC 8 MYSTERIES
144
Let’s look at these last two points in more detail by
considering some things we saw in Topic 8:

Lots of the collections we have seen have their behaviour
expressed via an interface:
COLLECTIONS AND INTERFACES
145
Why? Based on what we’ve discussed:
• For services: a method in a class that wants to offer a
service using a collection (e.g. List), can accept any type
of this collection (e.g. ArrayList) as an argument,
without having to force single inheritance.
• But also for the reasons seen on Slide 143:
This is why we
cannot make
objects of the
List type.

SWAPPING THE UNDERLYING IMPLEMENTATION (1)
146
private ArrayList<Product> shoppingBasket;
…
public Customer(String name) {
shoppingBasket = new ArrayList<Product>();
…
}
public ArrayList<Product> getShoppingBasket() {
return shoppingBasket;
}
What if I want to store things
in a different format?

147
private LinkedList<Product> shoppingBasket;
…
shoppingBasket = new LinkedList<Product>();
…
}
public LinkedList<Product> getShoppingBasket() {
} Lots of changes!

148
private List<Product> shoppingBasket;
…
shoppingBasket = new ArrayList<Product>();
…
}
public List<Product> getShoppingBasket() {
}
This is therefore another example
of polymorphism, related to Java’s
data structures.

149
private List<Product> shoppingBasket;
…
shoppingBasket = new LinkedList<Product>();
…
}
public List<Product> getShoppingBasket() {
}
We call this coding to the interface, and it is a style choice.
If we want to change how this
interface is realised we can
do so trivially.

In our village, Basher and Shouter feature behaviours that
are always realised in different ways. That is, different
entities (such as trolls, werewolves and giants), always
shout or (get)Bash(Range), differently.
• This lack of default functionality, or unique
functionality in each implementation, justiﬁes the use
of an interface.
Similarly, a List or a Set feature behaviours that are usually
realised in different ways. That is, different collections (such
as ArrayList and LinkedList), usually present concrete
functionality (e.g. get and size) in different ways.
• Caveat: Usually is the key word here. In reality, things
are a little more complex…
UNIQUE BEHAVIOUR IN EACH IMPLEMENTATION
150

A quick detour into Abstract Classes…
151

In reality, for certain behaviours (methods) in the List interface,
there is functionality that could be shared between the classes that
implement this interface (e.g. the behaviour of subList).
• For some behaviours, all implementing classes can function in
the same way.
This might suggest that List should be a normal base class, such
that this functionality can be inherited.
However, the motivation for keeping List (and other collection
types) as interfaces remains: offering non-exclusive services, the
ability to switch implementations, and indeed a majority of the
behaviours are still unique for each implementation.
What’s the solution? What we really need is partial functionality.
PARTIAL FUNCTIONALITY? (1)
152

🤓
153
Here, AbstractList sits in-between the List interface and the
ArrayList implementation, ﬁlling in some functionality, while
passing on the constraints to complete other functionality.
The solution, in order to introduce partial functionality, is as
follows:
extends
implements
implements

154
In this way, ArrayList is still of List type (because
AbstractList implements List), and takes the beneﬁts of being
as such (e.g. service use), but it still able to inherit default
functionality from AbstractList, or reimplement it as it sees ﬁt.
In reality the ArrayList class is a bit of brat and decides to
reimplement almost everything from AbstractList, but it, and
other lists, still have the option to reuse functionality.
inherits
implements
implements
For
readability
only

The reasons AbstractList is able to function in this way is because it
is something called an abstract class.
An abstract class can be seen as half way between an interface, and a
base class: some methods are abstract (empty, like in an interface);
some are not.
• Methods marked abstract are designed to be reimplemented;
normal methods are designed to share functionality.
ABSTRACT CLASSES
155
public abstract class AbstractList implements List {
abstract public get(int index);
public List subList(int fromIndex, int toIndex) {
return (this instanceof RandomAccess ?
. . .
}

Like normal base classes, abstract classes:
• Can have non-abstract methods with functionality.
• Constructors (that must be invoked with a super call if
necessary).
• Non-static and non-ﬁnal ﬁelds.
Because of these things, like a base class, only one abstract
class can be extended.
ABSTRACT CLASSES: CLASS FEATURES
156

Like interfaces, abstract classes:
• Have methods without functionality, however these
methods are marked abstract in order to differentiate
them from the non-abstract methods that exist in the
same class.
• When you extend an abstract class, an implementation
must be provided for all of the abstract methods from
the class (unless the extending class is also abstract).
Due to their (potential) partial implementation, abstract
classes cannot be instantiated.
ABSTRACT CLASSES: INTERFACE FEATURES
157

Therefore, abstract classes aren’t designed to solve the
multiple inheritance problem, in the same way as interfaces.
Instead, they are:
• Designed to pass on common functionality in the
presence of some unknown functionality (subList
(common) vs get (unknown)).
• Designed to capture when there shouldn’t be objects of
a certain class (more in a moment).
WHY ARE ABSTRACT CLASSES USEFUL? (1)
158

Therefore, abstract classes aren’t designed to solve the multiple inheritance
problem, in the same way as interfaces.
Instead, they are:
• Designed to sit in-between an interface and an implementing class, in
order to create partial functionality (e.g. the relationship between
ArrayList, AbstractList and List).
• It is because objects cannot be made of an abstract class that it is
able to safely ignore the restrictions of an interface, which is that all
methods must be implemented.
• Instead, this restriction is passed on to any subclasses of the abstract
class (e.g. ArrayList must provide an implementation for get). Again,
unless that class is also abstract..
• Partial functionality can still be replaced, if needed via overriding
(which ArrayList chooses to do).
WHY ARE ABSTRACT CLASSES USEFUL? (2)
159

ASIDE: WHY WOULD I WANT TO INHIBIT INSTANCES OF A CLASS? (1)
160
When modelling the game of Battleship, we might decide to
organise the setting of a ship’s size by providing a superclass
that sets up parts etc., and this functionality can then be
called from the subclasses (including Battleship).
public class Ship {
private ArrayList<Part> parts;
public Ship(int row, int size) {
parts = new ArrayList<Part>();
for ( int i = 0; i < size; i++ ) {
parts.add(new Part(row, i));
}
}

But what is a ship? It doesn’t have a size, so it’s not really a thing;
it’s just part of an idea.
• We also wanted encapsulate the number of parts as ship has.
This can be captured by making a Ship class abstract (with optional
abstract methods, if we wanted) such that it is only designed to be
subclassed, and thus realised (i.e. when it is given parts):
ASIDE: WHY WOULD I WANT TO INHIBIT INSTANCES OF A CLASS? (2)
161
public class Battleship extends Ship {
private ArrayList<Part> parts;
public Battleship(int row) {
super(row, 5);
}
public abstract class Ship {
Credit to you guys for
leading me towards this
example.

We’ve talked a lot about using the interfaces designed by
other people.
But why we would want to build our own interfaces?
Lots of the reasons are the same:
• To encourage classes to support behaviours that allow
them to use our services.
• Conceptually, we may want to deﬁne an entity that
always has unique behaviour in each implementation.
• For implementation ﬂexibility.
WHY WOULD WE WANT TO USE INTERFACE IN OUR OWN CODE?
163

ASIDE: CREATING OUR OWN INTERFACES: HIDE-AND-SEEK
164
public interface GraphTraverser extends Comparable<GraphTraverser>, Runnable {
public HashSet<StringVertex> uniquelyVisitedNodes();
public HashSet<StringEdge> uniquelyVisitedEdges();
public ArrayList<StringVertex> allHideLocations();
I wanted people to be able to use the services offered by my method
method (exploring a graph), so I offered an interface for
implementation:
public class HiddenObjectGraph<V, E extends DefaultWeightedEdge> extends SimpleWeightedGraph<V, E> {
public boolean fromVertexToVertex(GraphTraverser traverser, V sourceVertex, V targetVertex) {
if ( containsEdge(sourceVertex, targetVertex) ) {
E traversedEdge = getEdge(sourceVertex, targetVertex);
double actualCost = this.getEdgeWeight(traversedEdge);
// The unique cost to the traverser, based upon their traversals so far
double uniqueCost = 0.0;

Next semester you will use interfaces when dealing with
events in graphical user interfaces (just to make things
confusing).
Here’s a sneak preview:
INTERFACES: GOING FORWARD
165
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("Boo!");
}
});
An
implementation
of that interface.
A service that calls a method
in an interface type when the
button is pressed.

😴
REMEMBER: ASIDE: OBJECTS IN MEMORY
166
In reality, unlike primitive values, objects are stored in
another area of the JVM’s memory known as the heap. The
variable containing the copy of the class is actually a
memory reference from a variable on the stack to an object
on the heap.
We’ll look at
this in more
detail next
semester.
We will use the deﬁnition of an object quite loosely in the ﬁrst
semester of PPA, in order to simplify things, and help your initial
understanding.

Dr. Martin Chapman
programming@kcl.ac.uk
martinchapman.co.uk/teaching
Programming Practice and Applications (4CCS1PPA)
Topic 9: Combining Objects
These slides will be available on KEATS, but will be subject to
ongoing amendments. Therefore, please always download a new
version of these slides when approaching an assessed piece of work,
or when preparing for a written assessment. 167
Thursday 1st December 2016

Programming in Java: Combining Objects

More Related Content

What's hot (19)

Similar to Programming in Java: Combining Objects (20)

More from Martin Chapman (20)

Recently uploaded (20)

Programming in Java: Combining Objects