Classes Anônimas

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy — lição 58 de 91.

Às vezes, você precisa de um objeto simples e único, sem a sobrecarga de definir uma classe completa. Classes anônimas permitem que você crie objetos dinamicamente, exatamente onde você precisa deles. Elas são particularmente úteis quando combinadas com injeção de dependência.

Uma classe anônima é definida usando new class seguida pelo corpo da classe:

<?php
$logger = new class {
    public function log(string $message): void {
        echo "Log: $message";
    }
};

$logger->log("Hello!");

Saída:

Log: Hello!

Classes anônimas tornam-se poderosas ao implementar interfaces. Isso é perfeito para testes ou quando você precisa de uma implementação rápida sem poluir sua base de código com classes de uso único:

<?php
interface Notifier {
    public function send(string $message): string;
}

function notify(Notifier $notifier, string $msg): string {
    return $notifier->send($msg);
}

$result = notify(new class implements Notifier {
    public function send(string $message): string {
        return "Sent: $message";
    }
}, "Test message");

echo $result;

Saída:

Sent: Test message

Classes anônimas também podem estender outras classes, usar traits e aceitar argumentos de construtor. Elas têm acesso total aos recursos de POO - são apenas definidas inline em vez de em um arquivo separado. Use-as quando uma definição de classe completa seria um exagero, mas você ainda precisa de um comportamento orientado a objetos.

Desafio

Fácil

Vamos construir um sistema de formatação de dados que demonstra o poder das classes anônimas. Em vez de criar arquivos de classe separados para implementações simples e únicas, você usará classes anônimas para criar implementações rápidas exatamente onde precisar delas.

Você organizará seu código em dois arquivos:

FormatterInterface.php — Defina uma interface chamada FormatterInterface com um único método format(string $data): string. Isso estabelece o contrato que qualquer formatador deve seguir.
main.php — Inclua o arquivo da interface e crie uma classe DataProcessor que use injeção de dependência para aceitar qualquer formatador. A classe deve:
- Aceitar uma FormatterInterface em seu construtor
- Ter um método process(string $data) que delega para o formatador injetado e retorna seu resultado
Você receberá duas entradas: um tipo de formato ("upper" ou "reverse") e uma string para formatar.

Com base no tipo de formato, crie uma classe anônima que implemente FormatterInterface:
- Para "upper": o método format() deve retornar os dados convertidos para maiúsculas
- Para "reverse": o método format() deve retornar os dados invertidos
Injete sua classe anônima em um DataProcessor, chame process() com a string de entrada e imprima o resultado.

Essa abordagem é perfeita quando você precisa de uma implementação rápida sem poluir sua base de código com arquivos de classe de uso único. A classe anônima é criada inline, implementa a interface necessária e pode ser passada para qualquer lugar onde essa interface seja esperada.

Folha de consulta

Classes anônimas permitem que você crie objetos dinamicamente sem definir uma classe completa. Elas são definidas usando new class seguido pelo corpo da classe:

<?php
$logger = new class {
    public function log(string $message): void {
        echo "Log: $message";
    }
};

$logger->log("Hello!");

Classes anônimas podem implementar interfaces, tornando-as úteis para injeção de dependência e testes:

<?php
interface Notifier {
    public function send(string $message): string;
}

function notify(Notifier $notifier, string $msg): string {
    return $notifier->send($msg);
}

$result = notify(new class implements Notifier {
    public function send(string $message): string {
        return "Sent: $message";
    }
}, "Test message");

Classes anônimas suportam todos os recursos de POO: elas podem estender outras classes, usar traits e aceitar argumentos no construtor. Use-as quando uma definição de classe completa for excessiva, mas você ainda precisar de comportamento orientado a objetos.

Experimente você mesmo

<?php
require_once 'FormatterInterface.php';

// TODO: Criar uma classe DataProcessor que:
// - Aceite uma FormatterInterface em seu construtor
// - Tenha um método process(string $data) que delega para o formatador

// Ler entrada
$formatType = trim(fgets(STDIN));
$inputString = trim(fgets(STDIN));

// TODO: Com base em $formatType ("upper" ou "reverse"), criar uma classe anônima
// que implemente FormatterInterface
// - Para "upper": format() deve retornar a versão em maiúsculas dos dados
// - Para "reverse": format() deve retornar a versão invertida dos dados

// TODO: Criar um DataProcessor com sua classe de formatador anônima
// Chamar process() com a string de entrada e imprimir o resultado

?>