La programmation orientée objet

<?php

declare(strict_types=1);

enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Shipped = 'shipped';
}

// ✗ Tout est public : n'importe quel code peut mettre la commande dans n'importe quel état
final class OpenOrder
{
    public OrderStatus $status = OrderStatus::Pending;
}

$open = new OpenOrder();
$open->status = OrderStatus::Shipped;   // expédiée sans avoir été payée, et rien ne l'empêche
echo 'Commande ouverte : ', $open->status->value, "\n";

// ✓ L'état se lit, mais ne change qu'à travers des méthodes qui portent les règles
final class Order
{
    public private(set) OrderStatus $status = OrderStatus::Pending;
    public private(set) ?string $trackingNumber = null;

    public function pay(): void
    {
        if ($this->status !== OrderStatus::Pending) {
            throw new LogicException('Seule une commande en attente peut être payée');
        }
        $this->status = OrderStatus::Paid;
    }

    public function ship(string $trackingNumber): void
    {
        if ($this->status !== OrderStatus::Paid) {
            throw new LogicException('Une commande doit être payée avant d\'être expédiée');
        }
        $this->status = OrderStatus::Shipped;
        $this->trackingNumber = $trackingNumber;
    }
}

$order = new Order();
try {
    $order->ship('FR123');
} catch (LogicException $error) {
    echo 'Refusé : ', $error->getMessage(), "\n";
}
$order->pay();
$order->ship('FR123');
echo 'Commande protégée : ', $order->status->value, ', suivi ', $order->trackingNumber, "\n";

<?php

declare(strict_types=1);

// La classe abstraite fixe le déroulement commun, et laisse un seul détail aux enfants
abstract class SalesReport
{
    /** @param list<array{product: string, quantity: int}> $rows */
    final public function render(array $rows): string
    {
        $lines = [$this->header()];
        foreach ($rows as $row) {
            $lines[] = $this->formatRow($row['product'], $row['quantity']);
        }
        $lines[] = 'Total : ' . array_sum(array_column($rows, 'quantity')) . ' article(s)';

        return implode("\n", $lines) . "\n";
    }

    // Les enfants DOIVENT écrire ces deux méthodes
    abstract protected function header(): string;

    abstract protected function formatRow(string $product, int $quantity): string;
}

final class CsvSalesReport extends SalesReport
{
    protected function header(): string
    {
        return 'product;quantity';
    }

    protected function formatRow(string $product, int $quantity): string
    {
        return "$product;$quantity";
    }
}

final class MarkdownSalesReport extends SalesReport
{
    protected function header(): string
    {
        return "| Produit | Quantité |\n|---|---|";
    }

    protected function formatRow(string $product, int $quantity): string
    {
        return "| $product | $quantity |";
    }
}

$rows = [
    ['product' => 'Clavier', 'quantity' => 3],
    ['product' => 'Souris', 'quantity' => 5],
];
echo (new CsvSalesReport())->render($rows), "\n";
echo (new MarkdownSalesReport())->render($rows), "\n";

try {
    new SalesReport();   // une classe abstraite ne s'instancie pas
} catch (Error $error) {
    echo $error->getMessage(), "\n";
}

<?php

declare(strict_types=1);

// Le contrat : ce que tout mode de livraison sait faire
interface ShippingMethod
{
    public function supports(string $code): bool;

    public function feeInCents(int $weightInGrams): int;
}

// Les implémentations : chacune sa règle, chacune dans sa classe
final class HomeDelivery implements ShippingMethod
{
    public function supports(string $code): bool
    {
        return $code === 'home';
    }

    public function feeInCents(int $weightInGrams): int
    {
        // 4,99 €, plus 1,50 € par kilo complet
        return 499 + intdiv($weightInGrams, 1000) * 150;
    }
}

final class PickupPoint implements ShippingMethod
{
    public function supports(string $code): bool
    {
        return $code === 'pickup';
    }

    public function feeInCents(int $weightInGrams): int
    {
        return 299;
    }
}

final class StorePickup implements ShippingMethod
{
    public function supports(string $code): bool
    {
        return $code === 'store';
    }

    public function feeInCents(int $weightInGrams): int
    {
        return 0;
    }
}

// Le code qui utilise : il ne connaît que l'interface, jamais les classes concrètes
final class ShippingCalculator
{
    /** @param iterable<ShippingMethod> $methods */
    public function __construct(private iterable $methods) {}

    public function feeInCents(string $code, int $weightInGrams): int
    {
        foreach ($this->methods as $method) {
            if ($method->supports($code)) {
                return $method->feeInCents($weightInGrams);
            }
        }

        throw new InvalidArgumentException("Mode de livraison inconnu : $code");
    }
}

$calculator = new ShippingCalculator([
    new HomeDelivery(),
    new PickupPoint(),
    new StorePickup(),
]);
foreach (['home', 'pickup', 'store'] as $code) {
    printf("%-6s 2,5 kg : %5.2f €\n", $code, $calculator->feeInCents($code, 2500) / 100);
}

<?php

// Dans Symfony, le conteneur de services fait l'assemblage à ta place

use Symfony\Component\DependencyInjection\Attribute\AutoconfigureTag;
use Symfony\Component\DependencyInjection\Attribute\AutowireIterator;

// 1. Toute classe qui implémente l'interface reçoit automatiquement l'étiquette
#[AutoconfigureTag('app.shipping_method')]
interface ShippingMethod
{
    public function supports(string $code): bool;

    public function feeInCents(int $weightInGrams): int;
}

// 2. Le calculateur reçoit tous les services qui portent cette étiquette
final class ShippingCalculator
{
    /** @param iterable<ShippingMethod> $methods */
    public function __construct(
        #[AutowireIterator('app.shipping_method')]
        private iterable $methods,
    ) {}
}

// 3. Ajouter un mode de livraison = créer une classe. Aucune autre ligne à modifier.

<?php

// Avec l'héritage, chaque combinaison de comportements demande sa propre classe…

class EmailNotifier {}
class LoggingEmailNotifier extends EmailNotifier {}
class SmsNotifier {}
class LoggingSmsNotifier extends SmsNotifier {}
class RetryingLoggingEmailNotifier extends LoggingEmailNotifier {}
class RetryingLoggingSmsNotifier extends LoggingSmsNotifier {}
// … et un nouveau canal (Slack) ou un nouveau comportement (retry) double le nombre de classes.

<?php

declare(strict_types=1);

interface Notifier
{
    public function send(string $to, string $message): void;
}

final class EmailNotifier implements Notifier
{
    public function send(string $to, string $message): void
    {
        echo "  [e-mail] à $to : $message\n";
    }
}

final class SmsNotifier implements Notifier
{
    public function send(string $to, string $message): void
    {
        echo "  [SMS] à $to : $message\n";
    }
}

// Un « décorateur » : il enveloppe N'IMPORTE QUEL Notifier et lui ajoute un comportement
final class LoggingNotifier implements Notifier
{
    public function __construct(private Notifier $inner) {}

    public function send(string $to, string $message): void
    {
        echo "  [log] envoi vers $to\n";
        $this->inner->send($to, $message);
    }
}

final class DisabledInTestNotifier implements Notifier
{
    public function __construct(private Notifier $inner, private bool $enabled) {}

    public function send(string $to, string $message): void
    {
        if ($this->enabled) {
            $this->inner->send($to, $message);
        }
    }
}

// On combine les morceaux comme des briques, sans créer de sous-classe
echo "E-mail journalisé :\n";
(new LoggingNotifier(new EmailNotifier()))->send('alice@example.com', 'Commande expédiée');

echo "SMS journalisé :\n";
(new LoggingNotifier(new SmsNotifier()))->send('+33600000000', 'Colis disponible');

echo "SMS désactivé (environnement de test) :\n";
(new DisabledInTestNotifier(new SmsNotifier(), enabled: false))->send('+33600000000', 'Rien');
echo "  (aucun envoi)\n";

<?php

declare(strict_types=1);

final readonly class Money
{
    // Constructeur privé : on passe forcément par une méthode
    // qui dit d'où vient la valeur
    private function __construct(public int $amountInCents) {}

    public static function fromCents(int $cents): self
    {
        return new self($cents);
    }

    // « 19,90 » ou « 19.90 », tel qu'on le saisit dans un formulaire
    public static function fromUserInput(string $input): self
    {
        if (preg_match('/^(\d{1,7})(?:[.,](\d{1,2}))?$/', trim($input), $parts) !== 1) {
            throw new InvalidArgumentException("Montant invalide : « $input »");
        }
        $cents = str_pad($parts[2] ?? '0', 2, '0');

        return new self((int) $parts[1] * 100 + (int) $cents);
    }
}

echo Money::fromCents(1990)->amountInCents, "\n";
echo Money::fromUserInput('19,9')->amountInCents, "\n";
echo Money::fromUserInput(' 7.05 ')->amountInCents, "\n";

try {
    Money::fromUserInput('12,345');
} catch (InvalidArgumentException $error) {
    echo $error->getMessage(), "\n";
}

<?php

declare(strict_types=1);

// L'événement : un simple objet qui décrit ce qui s'est passé
final readonly class OrderPlaced
{
    public function __construct(public int $orderId, public string $customerEmail) {}
}

// Un mini « dispatcher », pour voir le principe sans Symfony
final class EventDispatcher
{
    /** @var array<class-string, list<callable>> */
    private array $listeners = [];

    public function listen(string $eventClass, callable $listener): void
    {
        $this->listeners[$eventClass][] = $listener;
    }

    public function dispatch(object $event): void
    {
        foreach ($this->listeners[$event::class] ?? [] as $listener) {
            $listener($event);
        }
    }
}

$dispatcher = new EventDispatcher();

// Chaque réaction est indépendante, et la commande ne les connaît pas
$dispatcher->listen(OrderPlaced::class, function (OrderPlaced $event): void {
    echo "E-mail de confirmation à {$event->customerEmail}\n";
});
$dispatcher->listen(OrderPlaced::class, function (OrderPlaced $event): void {
    echo "Stock réservé pour la commande {$event->orderId}\n";
});

// Le code qui passe la commande se contente d'annoncer ce qui s'est passé
$dispatcher->dispatch(new OrderPlaced(1042, 'alice@example.com'));

<?php

// La même chose avec le composant EventDispatcher de Symfony

use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;

final class CheckoutService
{
    public function __construct(private EventDispatcherInterface $dispatcher) {}

    public function placeOrder(Order $order): void
    {
        // … enregistrement de la commande …
        $this->dispatcher->dispatch(new OrderPlaced($order->getId(), $order->getEmail()));
    }
}

// Symfony trouve ce listener tout seul grâce à l'attribut
#[AsEventListener]
final class SendOrderConfirmation
{
    public function __invoke(OrderPlaced $event): void
    {
        // … envoi de l'e-mail …
    }
}