ਕੀ ਪਾਬੰਦੀ (inheritance), ਐਬਸਟ੍ਰੈਕਟ ਕਲਾਸਾਂ ਅਤੇ ਇੰਟਰਫੇਸਾਂ ਕਿਵੇਂ ਕਾਮ ਕਰਦੀਆਂ ਹਨ?

Question

Accepted Answer

PHP ਇੱਕ OOP ਪਾਬੰਦੀ ਅਤੇ ਐਬਸਟ੍ਰੈਕਸ਼ਨ ਨੂੰ ਤਿੰਨ ਸਬੰਧਤ ਮਕੈਨਿਜ਼ਮਾਂ ਰਾਹੀਂ ਸਮਰਥਿਤ ਕਰਦਾ ਹੈ: **ਕਲਾਸ ਪਾਬੰਦੀ** (`extends`), **ਐਬਸਟ੍ਰੈਕਟ ਕਲਾਸਾਂ** (ਅਧੂਰੀ ਬੇਸ ਕਲਾਸਾਂ), ਅਤੇ **ਇੰਟਰਫੇਸਾਂ** (ਪ੍ਰੋਗ੍ਰਾਮ)। ਹਰੇਕ ਵਿਭਿੰਨ ਡਿਜ਼ਾਈਨ ਉਦੇਸ਼ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ।

## ਪਾਬੰਦੀ — ਇੱਕ ਮਾਪੇ ਦੀ ਕਲਾਸ ਨੂੰ ਵਧਾਉਣਾ

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

ਇੱਕ ਸਬਕਲਾਸ `extends` ਮਾਪੇ ਨੂੰ, ਇਸ ਦੀਆਂ ਮੈਂਬਰ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਸਵੈਚੱਛਾ ਨਾਲ ਇਸ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦਾ ਹੈ। `parent::` ਓਵਰਰਾਈਡ ਕੀਤੇ ਮਾਪੇ ਦੇ ਤਰੀਕੇ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। PHP **ਸਿੰਗਲ ਪਾਬੰਦੀ** (ਸਿਰਫ ਇੱਕ ਮਾਪਾ) ਨੂੰ ਸਮਰਥਿਤ ਕਰਦਾ ਹੈ।

## ਐਬਸਟ੍ਰੈਕਟ ਕਲਾਸਾਂ — ਇੱਕ ਅਧੂਰੀ ਬੇਸ (ਤਤਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ)

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

ਇੱਕ **ਐਬਸਟ੍ਰੈਕਟ ਕਲਾਸ** ਐਬਸਟ੍ਰੈਕਟ ਮੈਥਡਾਂ (ਸਬਕਲਾਸਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ) ਨੂੰ ਮੂਰਤ ਸਾਂਝੀ ਕੋਡ ਨਾਲ ਮਿਲਾਉਂਦੀ ਹੈ — ਇੱਕ ਬੇਸ ਜੋ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਤਤਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।

## ਇੰਟਰਫੇਸ — ਖਾਲਸ ਪ੍ਰੋਗ੍ਰਾਮ (ਕਈ ਅਨੁਮਤਿ ਹਨ)

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

ਇੱਕ **ਇੰਟਰਫੇਸ** ਇੱਕ ਪ੍ਰੋਗ੍ਰਾਮ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ (ਮੈਥਡ ਹਸਤਾਖਰ, ਕੋਈ ਲਾਗੂਕਰਨ ਨਹੀਂ)। ਇੱਕ ਕਲਾਸ **ਬਹੁਤ ਸਾਰੀਆਂ** ਇੰਟਰਫੇਸਾਂ ਨੂੰ `implement` ਕਰ ਸਕਦੀ ਹੈ — ਸਿੰਗਲ ਪਾਬੰਦੀ ਨੂੰ ਸਮਰਥਾ ਸਾਂਝਾ ਕਰਨ ਲਈ PHP ਦਾ ਤਰੀਕਾ।

## ਕਿਸ ਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਹੈ

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

## ਇਹ ਕਿਉਂ ਮੋਹਰੇ ਰੱਖਦਾ ਹੈ

ਪਾਬੰਦੀ, ਐਬਸਟ੍ਰੈਕਟ ਕਲਾਸਾਂ, ਅਤੇ ਇੰਟਰਫੇਸਾਂ ਕੋਰ OOP ਸਾਧਨ ਹਨ, ਅਤੇ ਫਰਕ ਨੂੰ ਸਮਝਣਾ ਚੰਗੀ ਤਰ੍ਹਾਂ ਬਣਾਏ ਗਏ PHP ਐਪਲੀਕੇਸ਼ਨਾਂ (ਅਤੇ ਫਰੇਮਵਰਕਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਜੋ ਇਨਹਾਂ ਉੱਤੇ ਬਹੁਤ ਨਿਰਭਰ ਹਨ) ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। **ਪਾਬੰਦੀ** (`extends`)