Object-Oriented

Programming

Composition and
Aggregation

Dr. Volodymyr Voytenko

15-04-27

Objectives
To become familiar with the two
relationship types: aggregation and
composition
To design system by identifying the classes
and discovering the relationships among
classes
To implement Java code segment in
classes design that follow relationships
guidelines
15-04-27

Inheritance (will be
considered later)
Vehicle
+drive()

Car
-sunRoof
15-04-27

Is-a relationship
Relationship between a
class and its refined
versions

Truck

Project update : more classes

Has -a relationship!
1. Vehicle has: Engine, Transmission, etc Component
existence depends on aggregate!
2.

Driver has Vehicle . Component existence may or may

not depend on aggregate

15-04-27

Aggregation
- Aggregation contains collections of
parts.
- Parts are living without whole
One test contains collection of 1 N questions :

Shared aggregation: M :N relationship between Class and Student.

List of students for a class is still changing. Doesnt matter when
student or class deleting or creating.

15-04-27

Composition
- Much stronger then aggregation : a composite
entity doesnt exist, if all parts dont exist
- Parts are created with whole and die with whole!

15-04-27

Aggregation &
Composition
Aggregation and Composition are modeling the
has-a relationship. If an object is exclusively
owned by an aggregated object, the
relationship between the object and its
aggregated object is always referred to as
composition.
Composition

Name

15-04-27

Aggregation

Person

Address

Identifying classes and

relationships

Example 1. Loan Borrower Project

Different type of loan products are available to
potential borrowers. We need to design a
management system of receiving loans by
different borrowers who satisfy specific
criteria. We need to keep track of borrowers
individual information and all updates about
current and prospective loans.
Person Address Borrower
Loan
Name

The best classes candidates ?

Relationship between classes ?
15-04-27

UML diagram:
Loan Borrower Project
Name

Person

-firstName: String
-mi: char
-lastName: String

-name: Name
-address: Address
+Person()
+Person(name: Name, address: Address)
+getName(): Name
+seName(name: Name): void
+getAddress(): Address
+setAddress(address: Address): void
+toString(): String

+Name()
+Name(firstName: String,
mi: char, lastName: String)
+getFirstName(): String
+getMi(): char
+getLastName(): String
+setFirstName(firstName:
String): void
+setMi(mi: char): void
+setLastName(lastName:
String): void
+getFullName(): String

Borrower
-loan: Loan

Loan

Name
15-04-27

Address
-street: String
-city: String
-state: String
-zip: String
+Address()
+Address(street: String, city: String,
state: String, zip: String)
+getStreet(): String
+getCity(): String
+getState(): String
+getZip(): String
+setStreet(street: String): void
+setCity(city: String): void
+setState(state: String): void
+setZip(zip: String): void
+getFullAddress(): String

+Borrower()
+Borrower(name: Name, address: Address)
+getLoan(): Loan
+setLoan(loan: Loan): void
+toString(): String

Person

Borrower

Loan

Address

Implementation in Java
An aggregation/composition relationship is usually represented as a data field in the aggregated class.

public class Name {

/** Data fields */
/** Constructors */
/** Methods */
}

public class Person {

/** Data fields */
private Name name;
private Address address;

public class Address {

/** Data fields */
/** Constructors */
/** Methods */
}

/** Constructors */
/** Methods */
}

Composition

Name

Aggregation

Person

Address

Inner Classes Translation

If Name or Address is used in the Person class
only, they can be declared as an inner class in
Person. Forpublic
example,
class Person {
private Name name;
private Address address;
...
class Name {
...
}
class Address {
...
}
}
15-04-27

Implementation : Java class

definition

To represent a general binary relationship that describes

an activity between two classes, we can use arrays:

public class Student {

/** Data fields */
private Course[]
courseList;

public class Course {

/** Data fields */
private Student[]
classList;
private Faculty faculty;

/** Constructors */
/** Methods */
}

/** Constructors */
/** Methods */
}

15-04-27

public class Faculty {

/** Data fields */
private Course[]
courseList;
/** Constructors */
/** Methods */
}

Using Inheritance and

Aggregation

In general, the difference between

inheritance and aggregation is the
difference between the is-a
relationship and the has-a relationship.
Sometimes, the choice between inheritance
and aggregation is not obvious. For
example, lets model the relationship
between Circle and Cylinder :

- Using inheritance
- Using aggregation
15-04-27

Using Inheritance or
Aggregation, cont.
public class Cylinder
{
private Circle
circle;

public class Cylinder

extends Circle
{
/** Constructors */

/** Constructors */
}

/** Methods */

/** Methods */
}

What is the best way to do it?

15-04-27

Using Inheritance or
Aggregation, cont.
1) Both designs are fine! (Check problem
domain!)
2) Which one is preferred?
If polymorphism is desirable, you need to use
the inheritance design. If you dont care about
polymorphism, the aggregation design gives
more flexibility because the classes are less
dependent using aggregation than using
inheritance.Favor aggregation over inheritance.
15-04-27

References
Liang, Introduction to Java Programming,(c)
2007-2015 Pearson Education, Inc.
Robert C. Martin, Designing object-oriented
C++ applications Using the Booch Method,
2005
UML basics: The class diagram. An
introduction to structure diagrams n UML 2,
Donald Bell, Architect, IBM Corporation, 2004
15-04-27

?
Thank you!
15-04-27