Selon quel principe les méthodes sont-elles…

Les méthodes dans les interfaces sont regroupées et séparées selon le principe de cohésion du comportement et le principe de contrat explicite.

Cohésion du comportement : Les méthodes représentant un ensemble unique d'opérations avec une entité ou effectuant des actions similaires sont regroupées dans une seule interface. Cela améliore la lisibilité du code, facilite la compréhension de l'objectif de l'interface et augmente sa réutilisabilité.
Contrat explicite : L'interface décrit un contrat explicite que les classes qui l'implémentent doivent respecter. Chaque méthode dans l'interface fait partie de ce contrat. Les méthodes sont réparties entre différentes interfaces si elles représentent des aspects différents du comportement ou si leur implémentation peut varier indépendamment. Par exemple, l'interface Readable peut contenir des méthodes pour lire des données, et Writable pour écrire. Une classe peut implémenter une ou les deux interfaces selon ses capacités.

Cette approche favorise les principes SOLID, notamment :

Principe de responsabilité unique : L'interface a une seule raison de changer, qui est la modification du ensemble de comportements qu'elle décrit.
Principe de ségrégation des interfaces : Les clients ne doivent pas dépendre d'interfaces qu'ils n'utilisent pas. Diviser de grandes interfaces en plus petites et ciblées permet aux classes d'implémenter uniquement celles dont elles ont réellement besoin.

Exemple :

Supposons que nous ayons une entité qui peut être sauvegardée et chargée. Au lieu d'une seule interface Persistable avec deux méthodes save() et load(), il est préférable de créer deux interfaces séparées :

// Interface pour les entités pouvant être sauvegardées
interface Savable
{
    public function save(): void;
}

// Interface pour les entités pouvant être chargées
interface Loadable
{
    public function load(): void;
}

Une classe pouvant être sauvegardée et chargée implémente les deux interfaces :

// Classe implémentant les deux interfaces
class DataObject implements Savable, Loadable
{
    public function save(): void
    {
        // Logique de sauvegarde
    }

    public function load(): void
    {
        // Logique de chargement
    }
}

Une classe ne pouvant être sauvegardée implémente uniquement Savable :

// Classe n'implémentant que l'interface Savable
class TempData implements Savable
{
    public function save(): void
    {
        // Logique de sauvegarde des données temporaires
    }
}

Cela permet de concevoir des classes et leurs dépendances de manière plus flexible.

Selon quel principe les méthodes sont-elles regroupées et séparées dans les interfaces?