Write an interface

An interface is a list of public method signatures with no bodies. It's a contract: "any class that signs this must have these methods".

          <?php

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

Implement it in real classes

A class implements an interface by providing every method it lists. Miss one, or get a type wrong, and PHP refuses to load the class.

          class EmailNotifier implements Notifier
          {
              public function send(string $to, string $message): void
              {
                  echo "📧 Emailing {$to}: {$message}" . PHP_EOL;
              }
          }

          class SmsNotifier implements Notifier
          {
              public function send(string $to, string $message): void
              {
                  echo "📱 Texting {$to}: {$message}" . PHP_EOL;
              }
          }
        

Depend on the interface, not the class

Here's the payoff. Type-hint the interface, and your code accepts any class that implements it. It has no idea, and doesn't care, which one it gets.

          class CommentAlert
          {
              public function __construct(private Notifier $notifier) {}

              public function newComment(string $author, string $postTitle): void
              {
                  $this->notifier->send($author, "New comment on {$postTitle}");
              }
          }

          (new CommentAlert(new EmailNotifier()))->newComment('ada@example.com', 'Hello Laravel');
          (new CommentAlert(new SmsNotifier()))->newComment('+15550100', 'Hello Laravel');
        

A class can implement several interfaces at once: class Post implements JsonSerializable, Countable.

Share code with an abstract class

An abstract class can't be created with new. It holds shared code and declares abstract methods that each child must fill in. This "parent runs the recipe, children supply one ingredient" shape is called the template method pattern.

          abstract class Report
          {
              abstract protected function rows(): array;

              public function toCsv(): string
              {
                  return implode(PHP_EOL, array_map(fn (array $r) => implode(',', $r), $this->rows()));
              }
          }

          class PopularPostsReport extends Report
          {
              protected function rows(): array
              {
                  return [['Hello Laravel', 1250], ['Arrays 101', 830]];
              }
          }

          echo (new PopularPostsReport())->toCsv();
          new Report();   // Error: Cannot instantiate abstract class Report
        

Choose: interface or abstract class?

They overlap, so here's a rule of thumb. You can also combine them: an abstract class can implement an interface and leave some methods for its children.

Reuse code anywhere with traits

A trait is a reusable chunk of methods (and properties) that you "copy in" with use inside a class. It solves "I want this behaviour in classes that don't share a parent".

          trait HasSlug
          {
              public function slug(): string
              {
                  return strtolower(trim(preg_replace('/[^a-z0-9]+/i', '-', $this->slugSource()), '-'));
              }

              abstract protected function slugSource(): string;
          }

          class Post
          {
              use HasSlug;
              public function __construct(public string $title) {}
              protected function slugSource(): string { return $this->title; }
          }

          class Category
          {
              use HasSlug;
              public function __construct(public string $name) {}
              protected function slugSource(): string { return $this->name; }
          }

          echo (new Category('PHP Tips'))->slug();   // php-tips