inheritance, abstract classes और interfaces कैसे काम करते हैं?

Question

Accepted Answer

PHP तीन संबंधित mechanisms के माध्यम से OOP inheritance और abstraction का समर्थन करता है: **class inheritance** (`extends`), **abstract classes** (आंशिक base classes), और **interfaces** (contracts)। प्रत्येक एक अलग design उद्देश्य पूरा करता है।

## Inheritance — एक parent class को extend करना

```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 एक parent को `extends` करता है, उसके members को inherit करता है और वैकल्पिक रूप से override करता है। `parent::` override किए गए parent method को call करता है। PHP **single inheritance** का समर्थन करता है (केवल एक parent)।

## Abstract classes — एक आंशिक base (instantiate नहीं किया जा सकता)

```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** abstract methods (subclasses को implement करना ही चाहिए) को concrete साझा code के साथ मिलाती है — एक base जिसे सीधे instantiate नहीं किया जा सकता।

## Interfaces — शुद्ध contracts (कई अनुमत हैं)

```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** एक contract परिभाषित करता है (method signatures, कोई implementation नहीं)। एक class **कई** interfaces को `implement` कर सकती है — capabilities साझा करने के लिए single inheritance के इर्द-गिर्द 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.
```

## यह क्यों महत्वपूर्ण है

Inheritance, abstract classes, और interfaces मूल OOP tools हैं, और इन भेदों को समझना अच्छी तरह से संरचित PHP applications design करने के लिए महत्वपूर्ण है (और frameworks के साथ काम करने के लिए, जो इन पर बहुत निर्भर करते हैं)। **Inheritance** (`extends`) "is-a" relationships के माध्यम से code reuse प्रदान करता है, लेकिन PHP केवल single inheritance की अनुमति देता है। **Abstract classes** दोनों implemented code और methods जिन्हें subclasses को परिभाषित करना ही चाहिए, के साथ एक साझा base प्रदान करते हैं — तर्क साझा करने वाली निकटता से संबंधित classes के लिए अच्छा। **Interfaces** contracts/capabilities परिभाषित करते हैं, और निर्णायक रूप से एक class उनमें से **कई** को implement कर सकती है — जो interfaces को flexible, decoupled designs की कुंजी और single-inheritance सीमा के लिए PHP का उत्तर बनाता है।

यह जानना कि प्रत्येक का उपयोग कब करें (is-a reuse के लिए inheritance, साझा आंशिक implementation के लिए abstract classes, contracts/capabilities के लिए interfaces), और **interfaces के प्रति programming** का सिद्धांत (testable, flexible, framework-friendly code के लिए abstractions पर निर्भर रहना), object-oriented PHP design के लिए महत्वपूर्ण ज्ञान है।

ये mechanisms इस बात की नींव हैं कि Laravel और Symfony जैसे frameworks अपने code को कैसे संरचित करते हैं (हर जगह interfaces और abstract base classes), जो इन्हें अपने स्वयं के code को अच्छी तरह से design करने और जिन frameworks पर आप निर्माण करते हैं उन्हें समझने दोनों के लिए आवश्यक बनाता है।