Inheritance, Association, Aggregation, and Composition

Inheritance, Association, Aggregation, and Composition

      1.  Inheritance [IS a relationship]

      2.  Association [Using Relationship]

      3. Aggregation [ Has a Relationship]

      4. Composition -  [Part of relationship]

1.      Inheritance [ IS a relationship]

Example

Consider there are two Classes.

1.Employee

2.Manager 

Here Employee is the Parent class; Manager is the child class.Manager is one of the types of Employee. Class Manager is a relation with Class Employee.

I.e. Manager is (a or an) Employee

2. Association [Using relationship]

Example

       1. Manager

       2. SwipeCard

Here Manager and SwipeCard are two different classes.

Manager uses a swipe card to enter XYZ premises.

I.e. Manager Using swipe card to enter XYZ premises.

The above diagram shows how the SwipeCard class uses the Manager class and the Manager class uses the SwipeCard class. You can also see how we can create objects of the Manager class and SwipeCard class independently and they can have their own object life time.

This relationship is called the “Association” relationship.

3.      Aggregation [ Has a Relationship]

Aggregation gives us a 'has-a' relationship. Within aggregation, the lifetime of the part is not managed by the whole. 

The above UML describes Aggregation relation which mentions that Employee refers to Address. And life time of Address is not managed by Employee. It is like"Employee has a Address". Let us see how it can be implemented in C#.

So how do we express the concept of aggregation in C#? Well, it's a little different to composition. Consider the following code:

public class Address
{
 . . .
}

public class Person

{

     private Address address;

     public Person(Address address)

     {

         this.address = address;

     }

     . . .

}

Person would then be used as follows:

Address address = new Address ();
Person person = new Person(address);

    Or

Person person = new Person (new Address() );

4. Composition  -  [Part of relationship]

Composition gives us a 'part-of' relationship.

If we were going to model a car, it would make sense to say that an engine is part-of a car. Within composition, the lifetime of the part (Engine) is managed by the whole (Car), in other words, when Car is destroyed, Engine is destroyed along with it. So how do we express this in C#?

public class Engine
{
 . . . 
}

public class Car

{

    Engine e = new Engine();

    .......

}

As you can see in the example code above, Car manages the lifetime of Engine.