Kif jaħdmu l-inheritance, l-abstract classes u l-interfaces?

Question

Accepted Answer

PHP tappoġġja l-OOP inheritance u l-abstraction permezz ta' tliet mekkaniżmi relatati: **class inheritance** (`extends`), **abstract classes** (partial base classes), u **interfaces** (contracts). Kull wieħed iservixxi għan għal disinn differenti.

## Inheritance — estendi klassi parent

```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, u terħa u tista' toffri l-override tal-members tiegħu. `parent::` isejjaħ il-parent method li ġie pprovdu l-override tiegħu. PHP tappoġġja **single inheritance** (parent wieħed biss).

## Abstract classes — partial base (ma tistax tinsstanzjata)

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

An **abstract class** tikkombina abstract methods (subclasses għandhom jimplimentaw) ma' concrete shared code — base li ma tistax tinsstanzjata direttament.

## Interfaces — pure contracts (multiple allowed)

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

An **interface** tiddefinixxi contract (method signatures, l-ebda implementazzjoni). Class tista' `implement` **ħafna** interfaces — il-mod ta' PHP biex idawwar il-single inheritance għat-tfixkil ta' capabilities.

## Meta tużża liema

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

## Għaliex Importanti

Inheritance, abstract classes, u interfaces huma tools essenzjali tal-OOP, u l-fhim tal-distinzjonijiet importanti għad-disinn ta' applikazzjonijiet PHP strutturati tajjeb (u għal xogħol ma' frameworks, li jiddependu ħafna fuq dawn). **Inheritance** (`extends`) jipprovdi reuse tal-code permezz ta' relazzjonijiet "is-a", iżda PHP jippermetti single inheritance biss. **Abstract classes** jipprovdu shared base ma' both implemented code u methods li subclasses għandhom jiddefinixxi — tajjeb għal classes relatati mill-qrib li jaqsmu logic. **Interfaces** jiddefinixxi contracts/capabilities, u crucially class tista' timplimenta **ħafna** minnhom — li jagħmlu interfaces il-ċavetta għal designs flessibili, decoupled u l-għajnuna ta' PHP għal-limitazzjoni tal-single-inheritance.

Il-għarfien meta tużża kull wieħed (inheritance għal is-a reuse, abstract classes għal shared partial implementation, interfaces għal contracts/capabilities), u l-prinċipju ta' **programming to interfaces** (dipendenza fuq abstractions għal testable, flexible, framework-friendly code), huwa għarfien importanti għad-disinn ta' object-oriented PHP.

Il-mekkaniżmi dawn huma l-bażi ta' kif frameworks bħal Laravel u Symfony jistrutturaw il-code tagħhom (interfaces u abstract base classes kullimkien), li jagħmluhom essenzjali kemm għad-disinn tajjeb tal-code tiegħek stess u għall-fhim tal-frameworks li tibnihom.