Por qual princípio os métodos são agrupados e…

Os métodos nas interfaces são agrupados e separados de acordo com o princípio de coesão de comportamento e o princípio de contrato explícito.

Coesão de comportamento: Os métodos que representam um conjunto único de operações com uma entidade ou que realizam ações semelhantes em significado são agrupados numa única interface. Isto melhora a legibilidade do código, facilita a compreensão do propósito da interface e aumenta a sua reutilização.
Contrato explícito: A interface descreve um contrato explícito que as classes que a implementam devem cumprir. Cada método na interface faz parte deste contrato. Os métodos são divididos entre diferentes interfaces se representam aspetos diferentes do comportamento ou se a sua implementação pode variar independentemente. Por exemplo, a interface Readable pode conter métodos para ler dados, e Writable para escrever. Uma classe pode implementar uma ou ambas as interfaces, dependendo das suas capacidades.

Esta abordagem favorece os princípios SOLID, em particular:

Princípio da responsabilidade única: A interface tem uma única razão para mudar, que é a modificação do conjunto de comportamentos que descreve.
Princípio da segregação de interfaces: Os clientes não devem depender de interfaces que não utilizam. Dividir interfaces grandes em outras mais pequenas e focadas permite que as classes implementem apenas as interfaces que realmente precisam.

Exemplo:

Suponhamos que temos uma entidade que pode ser guardada e carregada. Em vez de uma única interface Persistable com dois métodos save() e load(), é melhor criar duas interfaces separadas:

// Interface para entidades que podem ser guardadas
interface Savable
{
    public function save(): void;
}

// Interface para entidades que podem ser carregadas
interface Loadable
{
    public function load(): void;
}

Uma classe que pode ser guardada e carregada implementa ambas as interfaces:

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

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

Uma classe que só é guardada implementa apenas Savable:

// Classe que implementa apenas a interface Savable
class TempData implements Savable
{
    public function save(): void
    {
        // Lógica de salvamento de dados temporários
    }
}

Isto permite projetar classes e as suas dependências de forma mais flexível.

Por qual princípio os métodos são agrupados e separados nas interfaces?