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

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.

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