Object Aggregation examples
An Association is a composition of independently constructed and
externally visible parts. When we associate classes or objects, each
one keeps a reference to the ones it is associated with. When we
associate classes statically, one class will contain a reference to an
instance of the other class. For example:
Example #1 Class association
<?php
class MyDateTime {
function MyDateTime()
{
}
function now()
{
return date("Y-m-d H:i:s");
}
}
class Report {
var $_dt;
function Report()
{
$this->_dt = new MyDateTime();
}
function generateReport()
{
$dateTime = $this->_dt->now();
}
}
$rep = new Report();
?>
We can also associate instances at runtime by passing a reference in a
constructor (or any other method), which allow us to dynamically change
the association relationship between objects. We will modify the example
above to illustrate this point:
Example #2 Object association
<?php
class MyDateTime {
}
class MyDateTimePlus {
var $_format;
function MyDateTimePlus($format="Y-m-d H:i:s")
{
$this->_format = $format;
}
function now()
{
return date($this->_format);
}
}
class Report {
var $_dt; function Report()
{
}
function setMyDateTime(&$dt)
{
$this->_dt =& $dt;
}
function generateReport()
{
$dateTime = $this->_dt->now();
}
}
$rep = new Report();
$dt = new MyDateTime();
$dtp = new MyDateTimePlus("l, F j, Y (h:i:s a, T)");
$rep->setMyDateTime(&$dt);
echo $rep->generateReport();
$rep->setMyDateTime(&$dtp);
$output = $rep->generateReport();
?>
Aggregation, on the other hand, implies
encapsulation (hidding) of the
parts of the composition. We can aggregate classes by using a (static)
inner class (PHP does not yet support inner classes), in this case the
aggregated class definition is not accessible, except through the class
that contains it. The aggregation of instances (object aggregation)
involves the dynamic creation of subobjects inside an object, in the
process, expanding the properties and methods of that object.
Object aggregation is a natural way of representing a whole-part relationship,
(for example, molecules are aggregates of atoms), or can be used to
obtain an effect equivalent to multiple inheritance, without having to
permanently bind a subclass to two or more parent classes and their
interfaces. In fact object aggregation can be more flexible, in which we
can select what methods or properties to "inherit" in the aggregated
object.