Kepiye inheritance, abstract classes lan interfaces makarya?

Question

Accepted Answer

PHP ndhukung OOP inheritance lan abstraction kanthi telu mekanisme sing ana hubungane: **class inheritance** (`extends`), **abstract classes** (partial base classes), lan **interfaces** (contracts). Saben-saben nduweni tujuan desain sing beda.

## Inheritance — extend 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, inheriting lan opsional override members-ne. `parent::` njaluk overridden parent method. PHP ndhukung **single inheritance** (siji parent kuwaé).

## Abstract classes — partial base (ora bisa diinstansiasi)

```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** nggabung abstract methods (subclasses kudu ngimplementasi) karo concrete shared code — base sing ora bisa diinstansiasi langsung.

## Interfaces — pure contracts (multi 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 "..."; }
}
```

**Interface** ngedefinisikan contract (method signatures, ora ana implementasi). Class bisa `implement` **akeh** interfaces — cara PHP ngalasi single inheritance kanggo sharing capabilities.

## Kapan nggunakake sing endi

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

## Kepiye pentinge

Inheritance, abstract classes, lan interfaces minangka core OOP tools, lan ngerti pembedane penting kanggo ndesain PHP applications sing struktur apik (lan kanggo work karo frameworks, sing gantung banget ing iki). **Inheritance** (`extends`) nyediakake code reuse via "is-a" relationships, nanging PHP mung ngidini single inheritance. **Abstract classes** nyediakake shared base karo dumunung implemented code lan methods subclasses kudu define — apik kanggo closely-related classes sharing logic. **Interfaces** ngedefinisikan contracts/capabilities, lan penting class bisa implement **akeh** saka iki — nggawé interfaces kunci kanggo flexible, decoupled designs lan jawaban PHP kanggo single-inheritance limitation.

Ngerti kapan nggunakake saben-saben (inheritance kanggo is-a reuse, abstract classes kanggo shared partial implementation, interfaces kanggo contracts/capabilities), lan prinsip **programming to interfaces** (depending on abstractions kanggo testable, flexible, framework-friendly code), penting knowledge kanggo object-oriented PHP design.

Mekanisme iki ndasari kepiye frameworks kaya Laravel lan Symfony ngstruktur code-ne (interfaces lan abstract base classes nggenyo), nggawé essential kanggo dumunung ndesain code-mu dewe luwes lan ngerti frameworks sing dibangun ndhuwur.