¿Según qué principio se agrupan y separan los métodos…

Los métodos en las interfaces se agrupan y separan según el principio de cohesión del comportamiento y el principio de contrato explícito.

Cohesión del comportamiento: Los métodos que representan un conjunto único de operaciones con una entidad o que realizan acciones similares en significado se agrupan en una sola interfaz. Esto mejora la legibilidad del código, facilita la comprensión del propósito de la interfaz y aumenta su reutilización.
Contrato explícito: La interfaz describe un contrato explícito que las clases que la implementan deben cumplir. Cada método en la interfaz forma parte de este contrato. Los métodos se dividen entre diferentes interfaces si representan aspectos distintos del comportamiento o si su implementación puede variar independientemente. Por ejemplo, la interfaz Readable puede contener métodos para leer datos, y Writable para escribir. Una clase puede implementar una o ambas interfaces según sus capacidades.

Este enfoque favorece los principios SOLID, en particular:

Principio de responsabilidad única: La interfaz tiene una sola razón para cambiar, que es la modificación del conjunto de comportamientos que describe.
Principio de segregación de interfaces: Los clientes no deben depender de interfaces que no utilizan. Dividir interfaces grandes en otras más pequeñas y enfocadas permite que las clases implementen solo las interfaces que realmente necesitan.

Ejemplo:

Supongamos que tenemos una entidad que puede ser guardada y cargada. En lugar de una sola interfaz Persistable con dos métodos save() y load(), es mejor crear dos interfaces separadas:

// Interfaz para entidades que se pueden guardar
interface Savable
{
    public function save(): void;
}

// Interfaz para entidades que se pueden cargar
interface Loadable
{
    public function load(): void;
}

Una clase que puede ser guardada y cargada implementa ambas interfaces:

// Clase que implementa ambas interfaces
class DataObject implements Savable, Loadable
{
    public function save(): void
    {
        // Lógica de guardado
    }

    public function load(): void
    {
        // Lógica de carga
    }
}

Una clase que solo se guarda implementa solo Savable:

// Clase que solo implementa la interfaz Savable
class TempData implements Savable
{
    public function save(): void
    {
        // Lógica de guardado de datos temporales
    }
}

Esto permite diseñar clases y sus dependencias de manera más flexible.

¿Según qué principio se agrupan y separan los métodos en las interfaces?