Cum funcționează moștenirea, clasele abstracte și interfețele?

Question

Accepted Answer

PHP suportă moștenirea OOP și abstracția prin trei mecanisme conexe: **moștenirea de clase** (`extends`), **clasele abstracte** (clase de bază parțiale), și **interfețele** (contracte). Fiecare servește un scop de design diferit.

## Moștenire — extinde o clasă părinte

```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
    }
}
```

O subclasă `extends` o clasă părinte, moștenind și opțional suprascriind membrii acesteia. `parent::` apelează metoda părinte suprascrisa. PHP suportă **moștenire simplă** (un singur părinte).

## Clase abstracte — o bază parțială (nu poate fi instanțiată)

```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
```

O **clasă abstractă** combină metode abstracte (subclasele trebuie să le implementeze) cu cod partajat concret — o bază care nu poate fi instanțiată direct.

## Interfețe — contracte pure (multiple permise)

```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 "..."; }
}
```

O **interfață** definește un contract (semnături de metode, fără implementare). O clasă poate `implement` **mai multe** interfețe — modul PHP de a ocoli moștenirea simplă pentru partajarea capabilităților.

## Când să folosești care

```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.
```

## De ce este important

Moștenirea, clasele abstracte și interfețele sunt instrumente OOP fundamentale, iar înțelegerea distincțiilor este importantă pentru proiectarea de aplicații PHP bine structurate (și pentru lucrul cu framework-uri, care se bazează foarte mult pe acestea). **Moștenirea** (`extends`) oferă reutilizare de cod prin relații "is-a", dar PHP permite doar moștenire simplă. **Clasele abstracte** oferă o bază partajată cu atât cod implementat cât și metode pe care subclasele trebuie să le definească — bune pentru clase strâns înrudite care partajează logică. **Interfețele** definesc contracte/capabilități, și crucial o clasă poate implementa **mai multe** dintre ele — făcând interfețele cheia pentru design-uri flexibile, decuplate și răspunsul PHP la limitarea moștenirii simple.

Cunoscând când să folosești fiecare (moștenire pentru reutilizare is-a, clase abstracte pentru implementare parțială partajată, interfețe pentru contracte/capabilități), și principiul **programării pe interfețe** (dependență de abstracții pentru cod testabil, flexibil, prietenos cu framework-urile), este cunoaștere importantă pentru design-ul OOP în PHP.

Aceste mecanisme stau la baza modului în care framework-uri precum Laravel și Symfony structurează codul lor (interfețe și clase de bază abstracte peste tot), făcîndu-le esențiale atât pentru proiectarea propriului cod cât și pentru înțelegerea framework-urilor pe care le folosești.