Op basis van welk principe worden methoden…

Methoden in interfaces worden gegroepeerd en gescheiden volgens het principe van cohesie van gedrag en het principe van expliciet contract.

Cohesie van gedrag: Methoden die een unieke set operaties met een entiteit vertegenwoordigen of vergelijkbare handelingen uitvoeren, worden samengevoegd in één interface. Dit verbetert de leesbaarheid van de code, vergemakkelijkt het begrip van het doel van de interface en verhoogt de herbruikbaarheid.
Expliciet contract: De interface beschrijft een expliciet contract dat de implementerende klassen moeten naleven. Elke methode in de interface maakt deel uit van dit contract. Methoden worden verdeeld over verschillende interfaces als ze verschillende aspecten van gedrag vertegenwoordigen of als hun implementatie onafhankelijk kan variëren. Bijvoorbeeld, de Readable interface kan methoden bevatten voor het lezen van gegevens, en Writable voor het schrijven. Een klasse kan één of beide interfaces implementeren afhankelijk van haar mogelijkheden.

Deze aanpak ondersteunt de SOLID-principes, in het bijzonder:

Single Responsibility Principle: De interface heeft één reden tot verandering — de verandering van het gedrag dat het beschrijft.
Interface Segregation Principle: Klanten mogen niet afhankelijk zijn van interfaces die ze niet gebruiken. Het opsplitsen van grote interfaces in kleinere en gerichte interfaces stelt klassen in staat om alleen die interfaces te implementeren die ze echt nodig hebben.

Voorbeeld:

Stel dat we een entiteit hebben die opgeslagen en geladen kan worden. In plaats van één Persistable interface met twee methoden save() en load(), is het beter om twee aparte interfaces te maken:

// Interface voor opslaanbare entiteiten
interface Savable
{
    public function save(): void;
}

// Interface voor laadbare entiteiten
interface Loadable
{
    public function load(): void;
}

Een klasse die zowel opgeslagen als geladen kan worden, implementeert beide interfaces:

// Klasse die beide interfaces implementeert
class DataObject implements Savable, Loadable
{
    public function save(): void
    {
        // Logica voor opslaan
    }

    public function load(): void
    {
        // Logica voor laden
    }
}

Een klasse die alleen opgeslagen wordt, implementeert alleen Savable:

// Klasse die alleen de `Savable` interface implementeert
class TempData implements Savable
{
    public function save(): void
    {
        // Logica voor tijdelijke gegevens opslaan
    }
}

Dit maakt het mogelijk om klassen en hun afhankelijkheden flexibeler te ontwerpen.

Op basis van welk principe worden methoden gegroepeerd en gescheiden in interfaces?