# Association Between Classes

**Class coupling** is a measure of how *interconnected* classes and subsystems are.

* **Tight coupling** means changing the code in class A impacts class D, which impacts class F, and so on.
* **Loose coupling** means changing the code in class A doesn't require you to change anything else.

To achieve *loose coupling*, we need to understand

* Encapsulation
  * No class knows the details about how any other class works
* The relationships between classes
* Interfaces

## Relationships Between Classes

There are 2 types of relationships between classes:

* Inheritance
* Composition

## Inheritance

**Inheritance** is a relationship between two classes that allows one to *inherit* code from another. This is known as an **is-a** relationship: a truck is a vehicle.

The class being inherited from is known as the **parent or base or super class**. The class doing the inheriting is known as the **child or derived or sub class**.

Benefits:

* Code re-use
* Polymorphic behaviour (will speak more about this in a separate section)

### Syntax

```cs
public class Vehicle
{
  // Common shared code
}

public class Truck : Vehicle
{
  // Code specific to Truck
}
```

**Pro tip**: When you create any class, it automatically inherits from the `Object` class! That means you have access its basic methods and properties/fields.

## Composition

**Composition** is a relationship between two classes that allows one to *container* another. This is known as a **has-a** relationship: a car has an engine.

The class placed *inside* the other class is known as the **composite class**.

Benefits:

* Code re-use
* Flexibility
* Promotes loose coupling

### Real-world example

Here's a real-world use case for composition. Imagine you have 2 classes: `DbMigrator` and `Installer`. These classes are responsible for specific tasks in your application.

Now imagine that both classes require logging because the business wants to track the health of its processes. We can create a `Logger` class for this and place an instance of it inside `DbMigrator` and `Installer`.

### Syntax

In C#, there's no special syntax. You're just storing your composite class inside the main class as a private field.

```cs
public class Logger
{
  public void Log(string message)
  {
    Console.WriteLine(message);
  }
}

public class Installer
{
  private Logger _logger;

  public Installer(Logger logger)
  {
    _logger = logger;
  }

  public void Install()
  {
    _logger.log("Installing application...");
  }
}
```

## Favour Composition over Inheritance

### Problems with inheritance

The problem with inheritance is that developers can abuse it, creating *large hierarchies* where changing one class trickles down to all its ancestors.

For example, imagine we have an `Animal` class that gets inherited from a `Person` and `Dog` class. Suppose at the time of creating this relationship, we add a `Walk` method to the `Animal` class.

What happens now if we want to add a `Goldfish` class? Then we probably have to move the `Walk` method to a `Mammal` class, which inherits `Animal`. Then we make `Person` and `Dog` inherit from `Mammal`.

This is what tight coupling looks like.

### Advantages of composition

**Any inheritance relationship can be translated to composition**.

Instead of thinking, "a person is an animal", you think, "a person *has* an animal" and a "person *has* a walkable".

In other words, you *compose* the functionality you need in a class by tying together a bunch of other classes.

**TLDR**: The main benefit of composition is that it's easy to **add a new class** tomorrow without having to go back and change everything else. If you're missing some functionality for this new class, just create another composite class to insert into your new class.

### Summary

Inheritance's pros:

* Code re-use
* Inheritance is more intuitive, as thinking about relationships as "has-a" can be awkward

Inheritance's cons:

* Tightly coupled
* Easily abused to create fragile large hierarchies

Composition's pros:

* Code re-use
* Greater flexibility
* Loose coupling due to lack of hierarchies

Composition's cons:

* A little harder to understand "has-a" relationships