Inheritance, abstract classes na interfaces hufanya kazi vipi?

Question

Accepted Answer

PHP inasaidia OOP inheritance na abstraction kupitia mifumo mitatu inayohusiana: **class inheritance** (`extends`), **abstract classes** (base classes za sehemu), na **interfaces** (contracts). Kila moja inatumikia kusudi tofauti la design.

## Inheritance — panua 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
    }
}
```

Subclass `extends` parent, ikirithi na kwa hiari ku-override members zake. `parent::` huita parent method iliyo-override-iwa. PHP inasaidia **single inheritance** (parent mmoja tu).

## Abstract classes — base ya sehemu (haiwezi kuwa 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
```

**Abstract class** huchanganya abstract methods (subclasses lazima zi-implement) na concrete shared code — base ambayo haiwezi kuwa instantiated moja kwa moja.

## Interfaces — contracts safi (nyingi zinaruhusiwa)

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

**Interface** hufafanua contract (method signatures, hakuna implementation). Class inaweza `implement` interfaces **nyingi** — njia ya PHP ya kukwepa single inheritance kwa kushiriki capabilities.

## Wakati wa kutumia ipi

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

## Kwa nini ni muhimu

Inheritance, abstract classes, na interfaces ni vifaa vya msingi vya OOP, na kuelewa tofauti ni muhimu kwa kubuni PHP applications zilizopangwa vizuri (na kwa kufanya kazi na frameworks, ambazo hutegemea hizi sana). **Inheritance** (`extends`) hutoa code reuse kupitia "is-a" relationships, lakini PHP huruhusu single inheritance pekee. **Abstract classes** hutoa base iliyoshirikiwa yenye code iliyo-implement-iwa na methods ambazo subclasses lazima zifafanue — nzuri kwa classes zinazohusiana kwa karibu zinazoshiriki logic. **Interfaces** hufafanua contracts/capabilities, na muhimu sana class inaweza kutekeleza **nyingi** kati yao — na hivyo kuzifanya interfaces kuwa ufunguo wa designs zinazonyumbulika, zilizotenganishwa (decoupled), na jibu la PHP kwa kikwazo cha single-inheritance.

Kujua wakati wa kutumia kila moja (inheritance kwa is-a reuse, abstract classes kwa shared partial implementation, interfaces kwa contracts/capabilities), na kanuni ya **programming to interfaces** (kutegemea abstractions kwa code inayoweza kutestiwa, kunyumbulika, na rafiki kwa framework), ni ujuzi muhimu kwa object-oriented PHP design.

Mifumo hii ndiyo inayounda jinsi frameworks kama Laravel na Symfony zinavyopanga code yao (interfaces na abstract base classes kila mahali), na hivyo kuzifanya muhimu kwa kubuni code yako mwenyewe vizuri na kuelewa frameworks unazojenga juu yake.