Composition, Aggregation, and
Inheritance - Introduction
SE-1020
Dr. Mark L. Hornick
1
Prior to this chapter, all of our objects have been
relatively simple, so we've been able to describe each
object with just a single class.
This is the natural approach when the attributes are all
simple elements.
class diagram
Automobile
-
make: String
model: String
year: int
color: java.awt.Color
+
soundHorn(int :duration) : void
2
Composition
For an object that's more complex (non-trivial
attributes), break up the object into its constituent
parts and defining one class as the whole and other
classes as parts of the whole.

When the whole class is the exclusive owner of the parts
classes, then that class organization is called a composition.
class diagram
Engine
Automobile
-
make: String
model: String
year: int
color: java.awt.Color
+
soundHorn(int :duration) : void
-
displacement: double
fuel: String
+
+
turnOff() : void
turnOn() : void
Note the “solid”
diamond!
Wheel
-
diameter: double
width: double
3
A nested composition hierarchy for the human body:
4
Composition semantics

In a composition hierarchy, the relationship between a
containing class and one of its part classes is known
as a has-a relationship.



For example, each human body has a brain and has a heart.
An automobile has an engine and has wheels.
Remember that with a composition relationship, a
component part is limited to just one owner at a time.


For example, a heart can be in only one body at a time.
An engine can only be in one automobile at a time.
5
Composition vs. Aggregation

There's another has-a relationship, called aggregation, which is
a weaker form of composition. With aggregation, one class is
the whole and other classes are parts of the whole (as with
composition), but there is no additional constraint that requires
parts to be exclusively owned by the whole.

An example where the parts (Students) are not exclusively
owned by the whole, because the Student can also be part of
another aggregation, like a School Club or Athletic Team.
class diagram
Note the “hollow”
diamond!
Course
-
title: String
instructor: String
section: int
credits: int
room: String
Student
-
name: String
birthdate: java.util.Date
major: String
6
UML Class Diagram details for Composition and
Aggregation

Universal Modeling Language (UML) Class diagrams show the
relationships between a program's classes:




A solid line between two classes represents an association – a relationship
between classes.
On an association line, a solid diamond indicates a composition relationship,
and a hollow diamond indicates an aggregation relationship. The diamond
goes next to the container class.

a simple straight line is an unspecified association
The labels on the association lines are called multiplicity values. They
indicate the number of object instances for each of the two connected classes.
The * multiplicity value represents any size number, zero through infinity.
7
UML Class Diagram illustrating “dependency”
class diagram
Math
BankAccount


-
balance: double
+
computeInterest() : double
+
+
pow(double, double) : double
sqrt(double) : double
Suppose the computeInterest() method of BankAccount uses the pow()
method of the Math class
When a class merely “uses” another class, that relationship is called a
dependency and is illustrated with a dotted line



A dotted line between two classes represents an dependency
A dependency line contains an arrow which points to the class (Math) that the
other class (BankAccount) depends upon.
It is not always necessary to illustrate dependencies
8
Classes with family ties
Sometimes we find that two (or more) classes could be
related to each other in the sense that


They are not the exactly the same, but they are not
completely different either
One of the classes is a “special case” of the other, and
needs to behave a little differently
Examples:
Class Automobile is a special case of class Vehicle
Class Beagle is a special case of Class Dog
This type of class relationship is called
Inheritance
SE-1020
Dr. Mark L. Hornick
9
Inheritance Example - People in a Department Store
Here's a UML class diagram for an inheritance hierarchy that keeps track
of people in a department store:
The Person class is generic
- it contains data and
methods that are common to
all classes in the hierarchy.
Person
-name : String
Customer
Employee
-address : String
-id : Integer
FullTime
-salary : Double
As you go down the hierarchy,
the classes get more specific.
For example, the Customer
and Employee classes
describe specific types of
people in the store.
PartTime
-hourlyWage : Double
10
Inheritance Terminology



Within an inheritance hierarchy, pairs of classes are linked
together. For each pair of linked classes, the more generic class
is called the superclass and the more specific class is called the
subclass.
We say that subclasses are derived from superclasses. That
makes sense when you realize that subclasses inherit all of the
superclass's data and methods.
Unfortunately, the terms superclass and subclass can be
misleading. The "super" in superclass could imply that
superclasses have more capability and the "sub" in subclass
could imply that subclasses have less capability. Actually, it's the
other way around - subclasses have more capability. Subclasses
can do everything that superclasses can do, plus more.


In fact, a subclass must be capable of doing everything a superclass does,
and should never violate the Liskov Substitution Principle
We'll stick with the terms superclass and subclass since those
are the formal terms used by Sun, but be aware of this
alternative terminology:


Programmers often use the terms parent class or base class when
referring to a superclass.
11 child class or derived class when
Programmers also use the terms
referring to a subclass.
The Java mechanism for defining a
inheritance relationship between two
classes is called extension:
class diagram
In Dog.java:
public class Dog{…}
Dog
In Beagle.java:
public class Beagle extends Dog{…}
-
name: String
age: int
+
+
Dog(name :String, age :int)
speak() : void
The extends keyword establishes the
inheritance relationship

Beagle
extends means “is a kind of”
+
+
SE-1020
Dr. Mark L. Hornick
speak() : void
Beagle(name :String, age :int)
12
Usually, UML class diagrams show
superclasses above subclasses.
That's a common practice, but not a requirement. The
following is a requirement….
 UML class diagrams use an arrow for inheritance
relationships, with a hollow arrowhead pointing to the
superclass.
Warning:
The direction of arrows in UML class diagrams is opposite
to the direction in which inheritance flows. In the diagram
the Beagle class inherits the name variable from the
Dog class. And yet the arrow does not go from Dog to
Beagle; it goes from Beagle to Dog. That's because
the arrow points to the superclass, and Dog is the
superclass.
UML class diagram review:
What are the class boxes' minus signs for?
What are the class boxes' third compartments
for?
13
class diagram
Dog
-
name: String
age: int
+
+
Dog(name :String, age :int)
speak() : void
Beagle
+
+
speak() : void
Beagle(name :String, age :int)
Benefits of Inheritance
It helps with code reusability 
1
2

A superclass's code can be used for multiple subclasses.
 That eliminates code redundancy and makes debugging
and upgrading easier.
A programmer can use an existing class to easily create a
new subclass (no need to "reinvent the wheel.")
Smaller modules (because classes are split
into superclasses and subclasses) 
That makes debugging and upgrading easier.
14
Rules of inheritance
class pets
All attributes and methods defined in a superclass
are inherited by all subclasses

Except for constructors!!!
But: Only protected and public attributes and
methods defined in the superclass are accessible
in the subclasses
 meaning only those superclass attributes
are visible to the subclasses
 And only those superclass methods are
callable by the subclasses
 Package attributes and methods are
accessible only if the subclass is in the
same package as the superclass
Superclass
~
#
+
privateAttr
packageAttr
protectedAttr
publicAttr
~
#
+
privateMethod()
packageMethod()
protectedMethod()
publicMethod()
methodA()
can only
access these
attributes and
methods
of the
superclass
Subclass
+
methodA() : void
Everything except the private members of the superclass is visible from
a method of the subclass
Private methods and attributes defined in a superclass are only accessible within the
superclass itself
SE-1020
Dr. Mark L. Hornick
15
Visibility from other classes
SomeOtherClass’s doSomething() method
can only access the public attributes and
methods of Superclass:
class pets
Superclass
• publicAttr
• publicMethod()
• and methodA() of Subclass
~
#
+
privateAttr
packageAttr
protectedAttr
publicAttr
~
#
+
privateMethod()
packageMethod()
protectedMethod()
publicMethod()
SomeOtherClass
+
doSomething() : void
Subclass
Package attributes and methods are
accessible if SomeOtherClass is in the
same package as Superclass and
Subclass
SE-1020
Dr. Mark L. Hornick
+
methodA() : void
16
Inheritance and Constructors

Unlike attributes and regular methods of a
superclass, constructors of a superclass are
not inherited by its subclasses

You must define a constructor for a subclass

or let the compiler add a default subclass
constructor
SE-1020
Dr. Mark L. Hornick
17
There are many cases in which a subclass
may want to utilize the behavior
implemented in a superclass constructor

So that the subclass does not have to completely
reimplement the same behavior


…which, remember, is not inherited
For example, if the Dog class has the following
constructor:
public void Dog(String name, int age) {
// Dog initialization goes here
}

Within the Beagle class:
public void Beagle(String name, int age) {
super(name, age); // invoke Dog ctor
// other statements can go here, but the FIRST statement
// must be the invocation
of the superclass ctor
SE-1020
18
Dr. Mark L. Hornick
}
If a superclass has only a default
constructor
public void BaseClass(){
// initialization code here
}

Within the derived class:
public void DerivedClass() {
super(); // invoke BaseClass default ctor
}
Portions adapted with permission from the textbook
author.
SE-1020
Dr. Mark L. Hornick
19
Actually, the invocation of a
superclass’s default constructor is
performed automatically when…
1.
2.
A subclass does not explicitly invoke it’s superclass
constructor
If the subclass does not contain a constructor
method at all
Portions adapted with permission from the textbook
author.
SE-1020
Dr. Mark L. Hornick
20
A subclass constructor must invoke a
superclass constructor whenever:
1.
The superclass does not contain a default constructor
2.
Private inherited attributes of the superclass need to
be initialized
Portions adapted with permission from the textbook
author.
SE-1020
Dr. Mark L. Hornick
21
A subclass method can
redefine a superclass method
class diagram
This is called overriding a
method

Do not confuse with method
overloading (which is where a class
Dog
-
name: String
age: int
+
+
Dog(name :String, age :int)
speak() : void
implements multiple methods having the
same name but different parameters)
Beagle
+
+

A subclass overrides a
superclass method to provide
a specialized behavior
SE-1020
Dr. Mark L. Hornick
speak() : void
Beagle(name :String, age :int)
Beagle provides it’s own custom
implementation of speak()
22
Method overriding is when a subclass has a
method with the same name and the same
parameter types as a method in its
superclass.
If a subclass contains an overriding method:


By default, an object of the subclass will use the subclass's
overriding method (and not the superclass's overridden
method).
Sometimes, an object of the subclass may need to call the
superclass's overridden method. To do that, preface the
method call with "super." (don't forget the dot).
If a subclass and a superclass have methods with the
same name, same parameter types, and different
return types, that generates a compilation error.
23
Methods modified with the final
keyword cannot be overridden

We declare a method final if we want to
prevent subclasses from changing the
behavior of the method via an override.
Similarly, classes modified with the final
keyword cannot be extended.
 We declare a class to be final if we want to
prevent subclasses from extending that class.
Portions adapted with permission from the textbook
author.
CS-1020
Dr. Mark L. Hornick
24