Kuinka perintö, abstraktit luokat ja rajapinnat toimivat?

Question

Accepted Answer

PHP tukee OOP-perintöä ja abstraktiota kolmen toisiinsa liittyvän mekanismin kautta: **luokkaperintö** (`extends`), **abstraktit luokat** (osittaiset kantaluokat) ja **rajapinnat** (sopimukset). Jokaisella on erilainen suunnittelutarkoitus.

## Perintö — laajenna kantaluokkaa

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

Aluokka `extends` kantaluokkaa, peri sen jäsenet ja voit halutessasi korvata ne. `parent::` kutsuu korvattua kantaluokan metodia. PHP tukee **yksinkertaista perintöä** (vain yksi vanhempi).

## Abstraktit luokat — osittainen kanta (ei voida instantioida)

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

**Abstrakti luokka** yhdistää abstraktit metodit (aliluokat täytyy toteuttaa) konkreettiseen jaettuun koodiin — kantaluokka, jota ei voi instantioida suoraan.

## Rajapinnat — puhtaat sopimukset (useita sallittu)

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

**Rajapinta** määrittelee sopimuksen (metodisignatuurit, ei toteutusta). Luokka voi `implement` **monia** rajapintoja — PHPin tapa kiertää yksinkertainen perintö kyvykkyyksiä jaetaessa.

## Milloin käyttää mitäkin

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

## Miksi sillä on merkitystä

Perintö, abstraktit luokat ja rajapinnat ovat perus-OOP-työkaluja, ja näiden erojen ymmärtäminen on tärkeää hyvin rakennettujen PHP-sovellusten suunnittelussa (ja kehyksiä käytettäessä, jotka luottavat vahvasti näihin). **Perintö** (`extends`) tarjoaa koodin uudelleenkäytön "on-a" -suhteilla, mutta PHP sallii vain yksinkertaisen perinnön. **Abstraktit luokat** tarjoavat jaetun kantaluokan sekä toteutetulla koodilla että metodeilla, jotka aliluokat täytyy määrittää — hyvä lähekkäin liittyville luokille, jotka jakavat logiikan. **Rajapinnat** määrittelevät sopimukset/kyvykkyydet, ja ratkaisevasti luokka voi toteuttaa **monia** niistä — mikä tekee rajapinnoista avaimen joustavaille, löyhästi kytkeytyneille suunnitteluille ja PHPin vastaukseksi yksinkertaisen perinnön rajoitukselle.

Tietäminen, milloin käyttää kutakin (perintö on-a-uudelleenkäytölle, abstraktit luokat jaetulle osittaiselle toteutukselle, rajapinnat sopimuksille/kyvykkyyksille) ja **rajapintoihin ohjelmoinnin** periaate (riippuvuus abstraktioista testattavaan, joustavaan, kehysystävälliseen koodiin) on tärkeä tieto objektisuuntautuneelle PHP-suunnittelulle.

Nämä mekanismit ovat pohjalla sille, kuinka kehykset kuten Laravel ja Symfony rakentavat koodensa (rajapintoja ja abstrakteja kantaluokkia kaikkialla), mikä tekee niistä oleellisiksi sekä omaan koodin suunnitteluun että niiden kehysten ymmärtämiseen, joihin rakennat.