In one sentence

Polymorphism means different objects can answer the same method call in their own way, so your code can treat them all alike.

🎵A conductor says "play" to the whole orchestra. The violin, the trumpet and the drum each respond differently, yet the conductor gives one instruction and never needs a separate speech for each instrument.

Why it matters

The trick behind Laravel's swappable drivers

🧹

Fewer if/else chains

Instead of checking "what type is this?" everywhere, you call one method and let each object handle it.

➕

Add without editing

New behaviour = a new class. Existing, tested code doesn't change. This is the open/closed principle.

🔀

Swap with one setting

File cache today, Redis tomorrow. Laravel switches drivers through config because they all share one interface.

The big picture

One call, many shapes

Checkout $gateway->pay() PaymentGateway interface: pay() 💳 StripeGateway 🅿️ PayPalGateway 🧪 FakeGateway
Checkout only knows the interface. Which pay() actually runs depends on the object it was given, decided at runtime.
Step by step

From type-checking to polymorphism

  1. Start with the problem: type-checking chains

    Without polymorphism, code ends up asking "which kind is this?" and branching. Every new payment method means editing this function, and similar match blocks spread across the codebase.

    
          function pay(string $method, int $cents): string
          {
              return match ($method) {
                  'stripe' => "Charged {$cents}¢ via Stripe",
                  'paypal' => "Charged {$cents}¢ via PayPal",
                  default  => throw new InvalidArgumentException("Unknown method {$method}"),
              };
          }

    match is great for mapping simple values. But when each branch is real behaviour that keeps growing, it's a sign you want polymorphism.

  2. Define the shared contract

    Pull the common action into an interface (from Abstraction & Interfaces). Each way of paying becomes its own class.

    
          <?php

          interface PaymentGateway
          {
              public function pay(int $cents): string;
          }

          final class StripeGateway implements PaymentGateway
          {
              public function pay(int $cents): string { return "Charged {$cents}¢ via Stripe"; }
          }

          final class PayPalGateway implements PaymentGateway
          {
              public function pay(int $cents): string { return "Charged {$cents}¢ via PayPal"; }
          }

  3. Write code that works with any implementation

    Type-hint the interface. Checkout calls pay() and PHP runs the right version for whichever object it holds. That's polymorphism: one call, many forms.

    
          final class Checkout
          {
              public function __construct(private PaymentGateway $gateway) {}

              public function complete(int $cents): string
              {
                  return $this->gateway->pay($cents);   // no if, no match
              }
          }

          echo (new Checkout(new StripeGateway()))->complete(1999);   // ...via Stripe
          echo (new Checkout(new PayPalGateway()))->complete(1999);   // ...via PayPal

  4. Add a new behaviour without touching old code

    Need a fake gateway for tests that never charges anyone? Write one class. Checkout doesn't change at all.

    
          final class FakeGateway implements PaymentGateway
          {
              public array $charges = [];

              public function pay(int $cents): string
              {
                  $this->charges[] = $cents;
                  return 'Pretended to charge';
              }
          }

          $fake = new FakeGateway();
          (new Checkout($fake))->complete(500);
          var_dump($fake->charges);   // [500]
    ℹ️ Polymorphism through inheritance, too

    It works with parent classes as well. A function typed Content $item accepts a Post or a Page, and $item->url() runs each child's override (see Inheritance).

  5. Treat a whole list the same way

    Polymorphism shines with collections. Loop over mixed objects and call the same method on each.

    
          /** @param list<Notifier> $channels */
          function broadcast(array $channels, string $message): void
          {
              foreach ($channels as $channel) {
                  $channel->send('team', $message);   // email, SMS, Slack... each in its own way
              }
          }

          broadcast([new EmailNotifier(), new SmsNotifier()], 'Deploy finished ✅');

    The /** @param ... */ line is a docblock. PHP can't type the contents of an array, so this comment tells your editor what's inside.

  6. Enums can be polymorphic too

    Enums can implement interfaces. Each case behaves differently through the same method, which is handy for small, fixed sets.

    
          interface HasPrice
          {
              public function monthlyCents(): int;
          }

          enum Plan: string implements HasPrice
          {
              case Free = 'free';
              case Pro = 'pro';

              public function monthlyCents(): int
              {
                  return match ($this) {
                      Plan::Free => 0,
                      Plan::Pro  => 1200,
                  };
              }
          }

          function invoiceTotal(HasPrice $item): int { return $item->monthlyCents(); }
          echo invoiceTotal(Plan::Pro);   // 1200
Common mistakes

Avoid this, do that

❌ Avoid

          if ($gateway instanceof StripeGateway) {
              $gateway->chargeStripe($cents);
          } elseif ($gateway instanceof PayPalGateway) {
              $gateway->sendPayPal($cents);
          }

Checking the class and calling differently named methods defeats the whole point.

✅ Do

          $gateway->pay($cents);

Give every implementation the same method from a shared interface, then just call it.

❌ Avoid

          class FakeGateway implements PaymentGateway
          {
              public function pay(int $cents): string
              {
                  throw new Exception('Not supported');
              }
          }

An implementation that breaks the promise surprises every caller that trusted the interface.

✅ Do

          public function pay(int $cents): string
          {
              $this->charges[] = $cents;
              return 'Pretended to charge';
          }

Every implementation should honour the contract, so callers never need special cases.

💡 Pro tip: smell the instanceof

Seeing the same instanceof or match ($type) check in several places? That's a hint to move the behaviour into the classes themselves.

🏋️ Try it yourself
  1. Create an interface Discount with apply(int $cents): int.
  2. Implement PercentOff (e.g. 10%), FixedOff (e.g. 500 cents) and NoDiscount.
  3. Write a Cart class that receives a Discount in its constructor and has a total(array $prices): int method.
  4. Loop over an array of all three discounts and print the cart total for each, without a single if.
  5. Bonus: add a BuyOneGetOne discount and confirm Cart needed no changes.
ℹ️ Where you'll see this in Laravel
  • Drivers: cache (file, database, Redis), queue, mail and filesystem drivers all implement shared contracts. Change CACHE_STORE=redis in .env and your code keeps calling Cache::get() (see Caching).
  • The Service Container lets you bind an interface to a concrete class, so PaymentGateway resolves to Stripe in production and a fake in tests (see The Service Container).
  • Notification channels: one notification, delivered through mail, database or broadcast channels.
  • Testing fakes: Mail::fake() and Queue::fake() swap in fake implementations (see Feature Tests).
  • Polymorphic relationships: a Comment can belong to a Post or a Video (see Relationships).
Recap

Key takeaways

Check yourself

Mini quiz