Hogyan működik az öröklődés, az absztrakt osztályok és az interfészek?

Question

Accepted Answer

A PHP az OOP öröklődést és absztrakciót három kapcsolódó mechanizmuson keresztül támogatja: **osztály-öröklődés** (`extends`), **absztrakt osztályok** (részleges alaposztályok), és **interfészek** (szerződések). Mindegyik eltérő tervezési célra szolgál.

## Öröklődés — egy szülőosztály kiterjesztése

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

Az alosztály `extends` egy szülőosztályt, örökölve annak tagjait, és opcionálisan felüldefiniálva azokat. A `parent::` meghívja a felüldefiniált szülőmetódust. A PHP **egyszeres öröklődést** támogat (csak egy szülő).

## Absztrakt osztályok — egy részleges alaposztály (nem példányosítható)

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

Egy **absztrakt osztály** absztrakt metódusokat (az alosztályoknak meg kell valósítaniuk) keveri össze a konkrét megosztott kóddal — egy olyan alaposztály, amely közvetlenül nem példányosítható.

## Interfészek — tiszta szerződések (több is megengedett)

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

Az **interfész** egy szerződést definiál (metódusszignatúrák, nincs megvalósítás). Egy osztály **sok** interfészt tud `implement`-álni — a PHP módja az egyszeres öröklődés megkerülésének a képességek megosztásához.

## Mikor melyiket használjuk

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

## Miért fontos

Az öröklődés, az absztrakt osztályok és az interfészek az OOP alapvető eszközei, és a megkülönböztetésük megértése fontos a jól strukturált PHP-alkalmazások tervezéséhez (és a keretrendszerek használatához, amelyek nagymértékben támaszkodnak ezekre). Az **öröklődés** (`extends`) kódújrafelhasználást biztosít az "is-a" relációkon keresztül, de a PHP csak egyszeres öröklődést engedélyez. Az **absztrakt osztályok** egy megosztott alapot biztosítanak megvalósított kóddal és azokkal a metódusokkal, amelyeket az alosztályoknak definiálniuk kell — jó a szorosan kapcsolódó osztályok számára, amelyek logikát osztanak meg. Az **interfészek** szerződéseket/képességeket definiálnak, és szalienciálisan egy osztály **sok** interfészt implementálhat — ami az interfészeket a kulcsná teszi a rugalmas, csatolt kóddal szembeni tervekhez és a PHP válaszához az egyszeres öröklődés korlátozásához.

Annak ismerete, hogy mikor melyiket használjuk (öröklődés az is-a újrafelhasználáshoz, absztrakt osztályok a megosztott részleges megvalósításhoz, interfészek a szerződésekhez/képességekhez), valamint az **interfészekre való programozás** elve (az absztrakciók függőségi programozása a tesztelhető, rugalmas, keretrendszer-barát kód érdekében) fontos ismeretek az objektumorientált PHP tervezéshez.

Ezek a mechanizmusok alapozzák meg, hogyan strukturálják a kódot az olyan keretrendszerek, mint a Laravel és a Symfony (interfészek és absztrakt alaposztályok mindenütt), ami elengedhetetlenné teszi azokat mind a saját kód jó megtervezéséhez, mind az alapul szolgáló keretrendszerek megértéséhez.