Hello Everybody, I am not able to differentiate b/w these 3 terms. Any one can please provide me with good link and example (preferably Java) and some explaination. Thanks in advance Nakul
Joined: May 29, 2000
Hello Nakul, Association, aggregation and composition can be mapped using attribute or method calling relatioship, it deppend of your model. Only in conceptually perpective you can differentiate between them. Talking about composition and aggregation: "...the difficult thing is considering what the difference is between agregation and association." [Martin Fowler] So, one example should not be used as a rule. I understand like this: - Association: one class calls methods from other. But this relationship can also be mapped as an attibute. - Agregation: one class is "part of" the other. It is like saying that a monitor is part of a computer. I always map this as an attribute. Here, more than one object may have a reference for the part object. - Composition: a particularly aggregation where the part object can not exist without the wrapper class. Also, the part object can only exist in one object and not in two object. The difference is like value and reference object concept [Fowler, page 93]. In Java, objects is passed by reference, and I would like to know how people map composition relationship. I would suggest to use part objects like attributes but not in more than one outer object. If we create objects only inside outer class and do not use its reference outside as other attribute, I understand it like a composite object. Comments, please. Adrian
Joined: Sep 20, 2001
Robert Martin has a pretty good explanation of this at http://ootips.org/uml-hasa.html (although the code examples are in C++). The interesting thing to note is that there isn't a precise mapping of Java syntax to these relationships. E.g. Any of the three could be represented (at least in part) with an instance variable. (paraphrasing Martin into Java terminology) an association can be implemented through an instance variable, although it might also be implemented as a method argument, or the creation of a local variable. Adrian in the prior post commented that he typically implements aggregations as an attribute (instance variable), but Martin also says that you need to avoid a cyclic relationship. Adrian's suggestion of using an Inner Class for Composition is fairly common as well, but with some care, a Composition relationship could be implented with between a pair of regular classes as well. Dave ------------------ firstname.lastname@example.org http://www.vraps.com http://www.houseofyin.com
David Kane<BR> <A HREF="mailto:email@example.com" rel="nofollow">firstname.lastname@example.org</A> <BR>Author of <A HREF="http://www.amazon.com/exec/obidos/ASIN/0130290327/ref=ase_electricporkchop/103-0514572-3811868" TARGET=_blank rel="nofollow">Software Architecture: Organizational Principles and Patterns</A><BR><A HREF="http://www.vraps.com" TARGET=_blank rel="nofollow">http://www.vraps.com</A><BR><A HREF="http://www.houseofyin.com" TARGET=_blank rel="nofollow">http://www.houseofyin.com</A>
Joined: May 12, 2001
Originally posted by David Kane: [B]Robert Martin has a pretty good explanation of this at http://ootips.org/uml-hasa.html (although the code examples are in C++).