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 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 do construtor. Elas têm acesso completo aos recursos de OOP — são apenas definidas diretamente no código, em vez de em um arquivo separado. Use-as quando uma definição completa de classe seria exagerada, mas você ainda precisar de comportamento orientado a objetos.

Desafio

Fácil

Vamos criar 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 pontuais, 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 um FormatterInterface em seu construtor
- Ter um método process(string $data) que delegue ao formatador injetado e retorne 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 exiba o resultado.

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

Experimente você mesmo

<?php
require_once 'FormatterInterface.php';

// TODO: Crie uma classe DataProcessor que:
// - Aceita um FormatterInterface em seu construtor
// - Tem um método process(string $data) que delega ao formatter

// Lê a entrada
$formatType = trim(fgets(STDIN));
$inputString = trim(fgets(STDIN));

// TODO: Based on $formatType ("upper" or "reverse"), create an anonymous class
// que implementa 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: Create a DataProcessor with your anonymous class formatter
// Chame process() com a string de entrada e imprima o resultado

?>