David B. wrote:
> I would like to implemente the "Aggregation" - as in
> http://en.wikipedia.org/wiki/Aggregation_(object-oriented_programming) -
> and the "Composition" - as

Wikipedia says that Composition is where a structure directly includes 
its members, whereas Aggregation is where a structure only contains 
references to those members.

This distinction doesn't apply in Ruby; everything is a reference, so 
Aggregation is your only option.

class Professor; end

class Department
  attr_accessor :members
  def initialize
    @members = []
  end
end

class University
  attr_accessor :faculty
  def initialize
    @faculty = []
  end
end

u = University.new
d = Department.new
u.faculty << d
p = Professor.new
d.members << p

Neither the arrays nor their elements are 'directly contained'; rather, 
references to those objects are stored. For example:

              @faculty
   University ------------> Array ---------> Department(1)
                                 '---------> Department(2)

If you no longer hold a reference to the University anywhere, then it 
will eventually be garbage collected. If this means that nothing else 
holds a reference to that particular Array, then that will be 
garbage-collected too. Ditto for the Departments, if there were no other 
references to them apart from those in the Array.

Arrays are untyped collections. Ruby won't enforce that 
University#faculty may only contain Department objects, nor that each 
Department may only be referenced from a single University (as the UML 
shows).
-- 
Posted via http://www.ruby-forum.com/.