Kaip veikia paveldėjimas, abstrakčios klasės ir sąsajos?

Question

Accepted Answer

PHP palaiko OOP paveldėjimą ir abstrakcionalavimą per tris susijusius mechanizmus: **klasės paveldėjimas** (`extends`), **abstrakčios klasės** (dalinės bazinės klasės) ir **sąsajos** (kontraktai). Kiekviena iš jų tarnauja skirtingam projektavimo tikslui.

## Paveldėjimas — išplėtimas iš pagrindinės klasės

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

Antrinė klasė `extends` pagrindinę, paveldėdama ir pasirinktinai perrašydama jos narius. `parent::` iškviečia perrašytą pagrindinės klasės metodą. PHP palaiko **vienintelį paveldėjimą** (tik viena pagrindinė klasė).

## Abstrakčios klasės — dalinė bazė (negali būti instancijuota)

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

**Abstrakčia klase** yra sujungiami abstraktūs metodai (antrinės klasės privalina juos įgyvendinti) su konkrečiu bendrinamuoju kodu — bazė, kurią negalima tiesiogiai instancijuoti.

## Sąsajos — grynai kontraktai (galima daugiau nei viena)

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

**Sąsaja** apibrėžia kontraktą (metodų parašus, be įgyvendinimo). Klasė gali **implementuoti kelis** kontraktus — tai yra PHP būdas aplenkti vienintelį paveldėjimą, skirstiantis galimybes.

## Kada naudoti ką

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

## Kodėl tai svarbu

Paveldėjimas, abstrakčios klasės ir sąsajos yra pagrindiniai OOP įrankiai, ir suprasti jų skirtumus svarbu gerai struktūrizuotoms PHP aplikacijoms kurti (ir dirbant su sistemomis, kurios jų intensyviai naudoja). **Paveldėjimas** (`extends`) suteikia kodo pakartotinį naudojimą per "yra" ryšius, bet PHP leidžia tik vienintelį paveldėjimą. **Abstrakčios klasės** suteikia bendrą bazę su tiek įgyvendintais kodais, tiek metodais, kuriuos antrinės klasės turi apibrėžti — tai gerai tinka glaudžiai susijusioms klasėms, skirstintis logiką. **Sąsajos** apibrėžia kontraktus/galimybes, ir svarbu, kad klasė gali implementuoti **daug** iš jų — sąsajos yra raktas į lankstų, atskirtą dizainą ir PHP atsaką į vienintelio paveldėjimo apribojimą.

Žinoti, kada naudoti ką (paveldėjimą "yra" ryšiams, abstrakčias klases bendroms dalinems įgyvendinimams, sąsajas kontraktams/galimybėms) ir **programavimo į sąsajas** principą (pasiklausčiant abstrakcijas bandomiems, lankstiems, sistemoms draugiškiems kodams), yra svarbi žinios objektinio orientavimo PHP dizainui.

Šie mechanizmai yra to, kaip sistemų, tokių kaip Laravel ir Symfony, struktūrizuojamas kodas (sąsajos ir abstrakčios bazinės klasės visur), todėl jie yra būtini tiek savo kodo gerai projektavimui, tiek jūsų naudojamų sistemų supratimu.