How do inheritance, abstract classes and interfaces work?

Question

Accepted Answer

PHP supports OOP inheritance and abstraction through three related mechanisms: **class inheritance** (`extends`), **abstract classes** (partial base classes), and **interfaces** (contracts). Each serves a different design purpose.

## Inheritance — extend a parent class

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

A subclass `extends` a parent, inheriting and optionally overriding its members. `parent::` calls the overridden parent method. PHP supports **single inheritance** (one parent only).

## Abstract classes — a partial base (can't be instantiated)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

An **abstract class** mixes abstract methods (subclasses must implement) with concrete shared code — a base that can't be instantiated directly.

## Interfaces — pure contracts (multiple allowed)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

An **interface** defines a contract (method signatures, no implementation). A class can `implement` **many** interfaces — PHP's way around single inheritance for sharing capabilities.

## When to use which

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Why it matters

Inheritance, abstract classes, and interfaces are core OOP tools, and understanding the distinctions is important for designing well-structured PHP applications (and for working with frameworks, which lean heavily on these). **Inheritance** (`extends`) provides code reuse via "is-a" relationships, but PHP allows only single inheritance. **Abstract classes** provide a shared base with both implemented code and methods subclasses must define — good for closely-related classes sharing logic. **Interfaces** define contracts/capabilities, and crucially a class can implement **many** of them — making interfaces the key to flexible, decoupled designs and PHP's answer to the single-inheritance limitation.

Knowing when to use each (inheritance for is-a reuse, abstract classes for shared partial implementation, interfaces for contracts/capabilities), and the principle of **programming to interfaces** (depending on abstractions for testable, flexible, framework-friendly code), is important knowledge for object-oriented PHP design.

These mechanisms underpin how frameworks like Laravel and Symfony structure their code (interfaces and abstract base classes everywhere), making them essential for both designing your own code well and understanding the frameworks you build on.