inheritance, abstract classes మరియు interfaces ఎలా పనిచేస్తాయి?

Question

Accepted Answer

PHP OOP inheritance మరియు abstraction మെకానిజమ్‌లను **class inheritance** (`extends`), **abstract classes** (partial base classes), మరియు **interfaces** (contracts) ద్వారా సపోర్ట్ చేస్తుంది. ఒక్కొక్క ఎక్కే ఆ విభిన్న డిజైన్ ఉద్దేశ్యం కోసం ఉపయోగించబడుతుంది.

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

A subclass `extends` ఒక parent, దాని members లను inherit చేస్తుంది మరియు ఐచ్ఛికంగా override చేస్తుంది. `parent::` overridden parent method ను call చేస్తుంది. PHP **single inheritance** మాత్రమే సపోర్ట్ చేస్తుంది (ఒక parent మాత్రమే).

## Abstract classes — ఒక partial 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
```

An **abstract class** abstract methods (subclasses తప్పనిసరిగా implement చేయాలి) concrete shared code తో mixing చేస్తుంది — ఒక base ఇది నేరుగా instantiate చేయలేనిది.

## 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** ఒక contract (method signatures, implementation లేనిది) define చేస్తుంది. ఒక class **many** interfaces లను `implement` చేయవచ్చు — PHP యొక్క single inheritance కు చుట్టూ ఉన్న సామర్థ్యాలను sharing చేయడానికి.

## ఏది ఎప్పుడు ఉపయోగించాలి

```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 core OOP tools, మరియు వాటి మధ్య వ్యత్యాసాలను అర్థం చేసుకోవడం PHP applications (మరియు frameworks తో పనిచేయడం కోసం, ఇవి ఎక్కువగా ఈ వాటిపై ఆధారపడుతుంది) ను well-structured చేయడానికి ముఖ్యమైనది. **Inheritance** (`extends`)