 | This articlemay containexcessive orirrelevant examples. Please helpimprove the article by adding descriptive text and removingless pertinent examples.(August 2010) |
Incomputer science,object composition andobject aggregation are closely related ways to combineobjects ordata types into more complex ones. In conversation, the distinction between composition and aggregation is often ignored.[1] Common kinds of compositions areobjects used inobject-oriented programming,tagged unions,sets,sequences, and variousgraph structures. Object compositions relate to, but are not the same as, data structures.
Object composition refers to the logical or conceptual structure of the information, not the implementation or physicaldata structure used to represent it[citation needed]. For example, asequence differs from aset because (among other things) the order of the composed items matters for the former but not the latter. Data structures such asarrays,linked lists,hash tables, and many others can be used to implement either of them. Perhaps confusingly, some of the same terms are used for both data structures and composites. For example, "binary tree" can refer to either: as a data structure it is a means of accessing a linear sequence of items, and the actual positions of items in the tree are irrelevant (the tree can be internally rearranged however one likes, without changing its meaning). However, as an object composition, the positions are relevant, and changing them would change the meaning (as for example incladograms)[citation needed].
Object-oriented programming is based on usingobjects toencapsulate data and behavior. It uses two main techniques for assembling and composing functionality into more complex ones, sub-typing and object composition.[2] Object composition is about combining objects within compound objects, and at the same time, ensuring the encapsulation of each object by using their well-definedinterface without visibility of their internals. In this regard, object composition differs from data structures, which do not enforce encapsulation.
Object composition may also be about a group of multiple related objects, such as a set or a sequence of objects.Delegation may enrich composition by forwarding requests or calls made to the enclosing composite object to one of its internal components.[3]
Inclass-based andtyped programming languages, types can be divided into composite and non-composite types, and composition can be regarded as a relationship between types: an object of a composite type (e.g.car) "has" objects of other types (e.g.wheel). When a composite object contains several sub-objects of the same type, they may be assigned to particularroles, often distinguished by names or numbers. For example, aPoint object might contain 3 numbers, each representing distance along a different axis, such as 'x', 'y', and 'z'. The study of part-whole relationships in general, ismereology.
Composition must be distinguished fromsubtyping, which is the process of adding detail to a general data type to create a more specific data type. For instance, cars may be a specific type of vehicle:caris avehicle. Subtyping doesn't describe a relationship between different objects, but instead, says that objects of a type are simultaneously objects of another type. The study of such relationships isontology.
Inprototype-based programming languages such asJavaScript, objects can dynamically inherit the behaviors from a prototype object at the moment of their instantiation. Composition must be distinguished from prototyping: the newly instantiated object inherits the composition of its prototype, but it may itself be composed on its own.
Composite objects may be represented in storage by co-locating the composed objects, by co-locating references, or in many other ways. The items within a composite object may be referred to asattributes,fields,members,properties, or other names, and the resulting composition ascomposite type,storage record,structure,tuple, or auser-defined type (UDT). For details, see theaggregation section below.
InUML modeling, objects can be conceptually composed, independently of the implementation with a programming language. There are four ways of composing objects in UML: property, association, aggregation and composition:[4]
The relationship between the aggregate and its components is a weak "has-a" relationship: The components may be part of several aggregates, may be accessed through other objects without going through the aggregate, and may outlive the aggregate object.[4] The state of the component object still forms part of the aggregate object.[citation needed]
The relationship between the composite and its parts is a strong “has-a” relationship: The composite object has sole "responsibility for the existence and storage of the composed objects", the composed object can be part of at most one composite, and "If a composite object is deleted, all of its part instances that are objects are deleted with it". Thus in UML, composition has a more narrow meaning than the usual object composition.
The graphical notation represents:
Aggregation differs from ordinary composition in that it does not imply ownership. In composition, when the owning object is destroyed, so are the contained objects. In aggregation, this is not necessarily true. For example, auniversity owns various departments (e.g.,chemistry), and each department has a number of professors. If the university closes, the departments will no longer exist, but the professors in those departments will continue to exist. Therefore, a university can be seen as a composition of departments, whereas departments have an aggregation of professors. In addition, a professor could work in more than one department, but a department could not be part of more than one university.
Composition is usually implemented such that an object contains another object. For example, inC++:
classProfessor;// Defined elsewhereclassDepartment{public:Department(conststd::string&title):title_(title){}private:// Aggregation: |Professors| may outlive the |Department|.std::vector<std::weak_ptr<Professor>>members_;conststd::stringtitle_;};classUniversity{public:University()=default;private:// Composition: |Department|s exist only as long as the faculty exists.std::vector<Department>faculty_={Department("chemistry"),Department("physics"),Department("arts"),};};
In aggregation, the object may only contain a reference or pointer to the object (and not havelifetime responsibility for it).
Sometimes aggregation is referred to as composition when the distinction between ordinary composition and aggregation is unimportant.
The above code would transform into the following UML Class diagram:
In Microsoft'sComponent Object Model, aggregation means that an object exports, as if it were their owner, one or severalinterfaces of another object it owns. Formally, this is more similar tocomposition orencapsulation than aggregation. However, instead of implementing the exported interfaces by calling the interfaces of the owned object, the interfaces of the owned object themselves are exported. The owned object is responsible for assuring that methods of those interfaces inherited fromIUnknown actually invoke the corresponding methods of the owner. This is to guarantee that the reference count of the owner is correct and all interfaces of the owner are accessible through the exported interface, while no other (private) interfaces of the owned object are accessible.[5]
Composition that is used to store several instances of the composited data type is referred to as containment. Examples of such containers arearrays,associative arrays,binary trees, andlinked lists.
InUML, containment is depicted with a multiplicity of 0..* or 1..*, indicating that the composite object is composed of an unknown number of instances of the composed class.
Objects can be composed recursively, and their type is then calledrecursive type. Examples includes various kinds oftrees,DAGs, andgraphs. Each node in a tree may be a branch or leaf; in other words, each node is a tree at the same time when it belongs to another tree.
In UML, recursive composition is depicted with an association, aggregation or composition of a class with itself.
Thecomposite design pattern is an object-oriented design based on composite types, that combines recursive composition and containment to implement complex part-whole hierarchies.
This is an example of composition inC.
structPerson{intage;charname[20];enum{job_seeking,professional,non_professional,retired,student}employment;};
In this example, the primitive (noncomposite) typesint,enum {job_seeking, professional, non_professional, retired, student} and the composite array typechar[] are combined to form the composite structurePerson. EachPerson structure then "has an" age, name, and an employment type.
C calls a record astruct or structure;object-oriented languages such asJava,Smalltalk, andC++ often keep their records hidden insideobjects (class instances); languages in theML family simply call them records.COBOL was the first widespreadprogramming language to support records directly;[6]ALGOL 68 got it from COBOL andPascal got it, more or less indirectly, from ALGOL 68.Common Lisp provides structures and classes (the latter via theCommon Lisp Object System).[citation needed]
01customer-record.03customer-numberpic 9(8)comp.03customer-name.05given-namespic x(15).05initial-2pic x.05surnamepic x(15).03customer-address.05street.07street-namepic x(15).09house-numberpic 999comp.05citypic x(10).05country-codepic x(3).05postcodepic x(8).03amount-owingpic 9(8)comp.
Arrays were the onlycomposite data type inAlgol 60.
dcl 1 newtypet based (P); 2 (a, b, c) fixed bin(31), 2 (i, j, k) float, 2 r ptr;allocate newtypet;
int max = 99;mode newtypet = [0..9] [0..max]struct ( long real a, b, c, short int i, j, k, ref real r);newtypet newarrayt = (1, 2, 3, 4, 5, 6, heap real := 7)
For example, a linked list might be declared as:
mode node = union (real, int, compl, string), list = struct (node val, ref list next);
For ALGOL 68 only the type name appears to the left of the equality, and most notably the construction is made – and can be read – from left to right without regard to priorities.
typea=array[1..10]ofinteger;b=recorda,b,c:real;i,j,k:integer;end;
#define max 99structnewtypet{doublea,b,c;floatr;shorti,j,k;}newarrayt[10][max+1];
Fortran 77 has arrays, but lacked any formal record/structure definitions. Typically compound structures were built up usingEQUIVALENCE orCOMMON statements:
CHARACTERNAME*32,ADDR*32,PHONE*16REALOWINGCOMMON/CUST/NAME,ADDR,PHONE,OWING
typeCustisrecordName:Name_Type;Addr:Addr_Type;Phone:Phone_Type;Owing:Integerrange1..999999;end record;
Ada 95 brought OOP concepts through tagged types (the equivalent of a C++ class), Ada 2012 added support forsubstitution verification through class-wide contracts.
constintmax=99;class{public:doublea,b,c;float&r;shorti,j,k;}newtypet[10][max+1];
max=99classNewTypeT:def__init__(self):self.a=self.b=self.c=0self.i=self.j=self.k=0.0# Initialise an example array of this class.newarrayt=[[NewTypeT()foriinrange(max+1)]forjinrange(10)]
Arrays and strings were inherited from FORTRAN 77, and a new reserved word was introduced:type
typenewtypetdouble precisiona,b,cinteger*2i,j,k*Nopointer typeREFREALRend typetype(newtypet)t(10,100)
FORTRAN 90 updated and includedFORTRAN IV's concept called NAMELIST.
INTEGER::jan=1,feb=2,mar=3,apr=4NAMELIST/week/jan,feb,mar,apr
Common Lisp provides structures and the ANSI Common Lisp standard added CLOS classes.
(defclasssome-class()((f:typefloat)(i:typeinteger)(a:type(arrayinteger(10)))))
For more details about composition in C/C++, seeComposite type.
There is a closely related concept to composition called aggregation. In conversation the differences between composition and aggregation are often ignored.
{{cite book}}: CS1 maint: others (link)