Wat is samenhang en koppeling in programmeren?

Samenhang (Cohesion) is een maat voor hoe nauw verbonden de elementen binnen een module (klasse, functie) zijn. Hoge samenhang betekent dat de elementen van de module gericht zijn op het uitvoeren van één taak of concept. Een goed ontworpen module heeft een hoge samenhang.

Voorbeelden van niveaus van samenhang (van laag naar hoog):

• Toevallig (Coincidental): Elementen zijn willekeurig verbonden, zonder logische relatie.
• Logisch (Logical): Elementen voeren een reeks logisch gerelateerde acties uit, maar de keuze wordt gemaakt door externe code.
• Tijdelijk (Temporal): Elementen zijn verbonden doordat ze gelijktijdig worden uitgevoerd.
• Procedureel (Procedural): Elementen volgen een uitvoeringsprocedure.
• Communicatief (Communicational): Elementen werken met dezelfde gegevens.
• Sequentieel (Sequential): De uitgang van het ene element is de ingang van een ander.
• Functioneel (Functional): Alle elementen dragen bij aan het uitvoeren van één duidelijk gedefinieerde functie.

De koppeling (Coupling) is een maat voor afhankelijkheid tussen verschillende modules. Een lage koppeling betekent dat de modules relatief onafhankelijk zijn. Het verminderen van koppeling maakt het systeem flexibeler, onderhoudsvriendelijker en testbaarder.

Voorbeelden van niveaus van koppeling (van hoog naar laag):

• Op inhoud (Content): Een module heeft directe toegang tot de interne gegevens of implementatie van een andere module.
• Gemeenschappelijk (Common): Modules gebruiken een gedeeld globale gegevensruimte.
• Controlemiddelen (Control): Een module geeft een controlevlag door die het gedrag van een andere module bepaalt.
• Stempel (Stamp): Overdracht van samengestelde gegevens (objecten, structuren), maar de module gebruikt slechts een deel ervan.
• Gegevens (Data): Overdracht van eenvoudige gegevens als parameters.
• Berichten (Message): Modules wisselen berichten uit (bijvoorbeeld via gebeurtenissen, interfaces). Dit is de zwakste vorm van koppeling.

Het doel van goed ontwerp: hoge samenhang (binnen modules) en lage koppeling (tussen modules).

<?php

// Voorbeeld van hoge samenhang (Functionele Cohesie)
// Deze klasse richt zich alleen op gebruikersbeheer
class UserManager {
    private array $users = [];

    public function addUser(string $name): void {
        $this->users[] = $name;
    }

    public function getUsers(): array {
        return $this->users;
    }

    public function deleteUser(string $name): void {
        $this->users = array_filter($this->users, fn($user) => $user !== $name);
    }
}

// Voorbeeld van lage koppeling (Data koppeling)
// 'processOrder' hangt alleen af van de meegegeven gegevens ($orderId, $amount)
class OrderProcessor {
    public function processOrder(int $orderId, float $amount): bool {
        // Logica voor orderverwerking...
        // Heeft geen directe afhankelijkheid van de implementatie van andere klassen,
        // alleen van de invoergegevens.
        echo "Verwerking van order ID $orderId met bedrag $amount\n";
        return true;
    }
}

// Voorbeeld waarin UserManager en OrderProcessor geen sterke afhankelijkheid van elkaar hebben.
// Ze kunnen onafhankelijk of samen worden gebruikt, maar hun interne wijzigingen
// beïnvloeden elkaar niet sterk.

?>