There are several degrees of relationships that can be modeled.

In an association, the state of the object depends on another object.  There are many types of association, such as owns (Tom owns the book), or works for (Jim works for Cynthia). The association affects both sides of the relationship.

In as association, the two objects have a strong connection but neither one is part of the other.  The objects participating in an association often have independent existences.

Aggregation And Composition

Aggregation and composition refer to relationships in which a class has references to objects of other classes.  They are a special form of association, sometimes referred to alternatively as the 'contains,' 'is composed of,' 'is comprised of,' 'is part of,' 'consists of,' or some other phrase that implies a containment relationship.  This technique allows reuse of existing code and collaboration with other implementations.

• These two types of relationships are similar in that they are both part-whole constructions. 
• What distinguishes aggregation from composition is the visibility of the parts. 

  
  
  

• See Overview
  
  

  ---

  • In aggregation the interacting parts are externally visible and, in fact, may be shared by different relationships. 
    • A computer workstation is an example of composition using aggregation. The workstation consists of a keyboard, a mouse, a monitor, a modem, and a processor. Each of these interacting parts are visible to the user and can be directly manipulated by the user.
    • Each of the components may be an object in its own right.
    • The example code demonstrates aggregation.
      • clsDate contains Private instance variables mMonth , mDay and mYear.
        
      • clsEmployee contains Private instance variables mFirstName, mLastName, mBirthDate and mHireDate.
        
      • Members mBirthDate and mHireDate are objects of class clsDate, so instances clsDate of occur inside clsEmployee. 
        
      • Another way of looking at it is to say that clsEmployee has instance variables of type String, String, clsDate, and clsDate.
        
      • The program instantiates an clsEmployee object and initializes and displays its instance variables.
        
      • One constructor takes eight arguments (fName, lName, bMonth, bDay, bYear, hMonth, hDay and hYear).
        
      • Arguments bMonth, bDay and bYear are passed to the birthDate constructor and hMonth, hDay and hYear are passed to the hireDate constructor.
        
      • The two classes exist independently.
        
    • See Aggregation
      

  ---

  • In an composition, only the whole is visible and accessible. 
    • A PC's system unit an example of composition, as the machine is a whole composed of several internal parts (a cooling system, CPU, memory, disk drives, etc.). These internal parts are not visible or accessible to the normal user of the PC. 
    • The component parts of the object come into existence only with the entire object.  The lifetime of the contained object is tied to the lifetime of the containing object.
    • Composition models a relationship in which one object is an integral part of (and contained within) another.
    • This example demonstrates composition.
      • Similar to the previous example, note that in composition the clsDate class in nested inside the clsEmployee.  
        
      • The classes do NOT exist independently.  If a clsEmployee object is deleted it takes the clsDate object with it.
        
    • See Composition

Aggregation and Composition

Both relationships are useful. 

• Composition offers greater security because its structure is usually defined in advance and cannot be altered at run-time. The implementer of the composition is secure in the knowledge that the integrity of the composition and its proper functioning cannot be adversely affected by direct interference with its internal mechanisms. 
  
• Aggregation offers greater flexibility because the relationships among the visible parts can be redefined at run-time. An aggregation can, therefore, be made to adapt to changing conditions in its execution environment by replacing one or more of its components. 

Some texts use the term composition generically.  This occurs when the statement applies to both forms, when the difference between the two forms is much less important than the general idea of forming a whole from parts, or when the precise relationship may be inferred from context.

Adapted from Object-Oriented Software Design and Construction with Java by Dennis Kafura

Shapiro addresses the concept of composition in the following excerpt.  He makes the distinction between aggregation and composition by noting that composition refers to nesting classes inside one another, while in aggregation they are two distinct classes.

Some OOP experts make a distinction between composition and aggregation; others will tell you they both mean the same thing. At the conceptual level, expressing an alternative to the is-a relationship, that may be true. But at the implementation level there are important differences, as you will shortly see.

While inheritance represents the is-a relationship between classes, aggregation and composition represent the has-a relationship between classes. A bus, for example, has seats for its passengers, but a bus is not a seat. The seats are embedded in the bus as member objects. Seats have their own class hierarchy, as do busses. The hierarchies of both classes remain separate and distinct because a bus cannot be a seat and visa versa.

Aggregation is exactly how your form classes come to life with all manner of functionality. You embed components and controls onto the form, like buttons and text boxes. Forms, buttons, and text boxes, however, are distinctly separate objects. A form is not a text box and a text box is not a button (although there may be traces of a common ancestor far back up the chain in the base classes for components and controls). 

Where aggregation differs from composition is that aggregate objects or aggregates are sub-types that are embedded in the container class and composite classes or composites are classes that are composed in (nested within) the container class. Aggregates are not exclusive to their container and may be embedded in other containers. Aggregates can be any exposed types in any assembly that can be declared and instantiated in the container class. Composites on the other hand are exclusive to their container. They are formally declared and implemented in a container class as a composite or nested class.

Additionally you always have direct access to the implementation, or source code, in a composite class. Aggregate objects are not exposed in this manner; you have no access to their implementation and source.

Code segment demonstrating Composition.