inheritance, abstract class และ interface ทำงานอย่างไร?

Question

Accepted Answer

PHP รองรับ inheritance และ abstraction แบบ OOP ผ่านกลไกที่เกี่ยวข้องกันสามอย่าง: **class inheritance** (`extends`), **abstract classes** (คลาสฐานบางส่วน) และ **interfaces** (สัญญา/contract) แต่ละอย่างทำหน้าที่ในการออกแบบที่แตกต่างกัน

## Inheritance — ขยายจากคลาสแม่

```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` คลาสแม่ โดยสืบทอดและ override สมาชิกของมันได้ตามต้องการ `parent::` เรียกเมธอดของคลาสแม่ที่ถูก override PHP รองรับ **single inheritance** (มีคลาสแม่ได้เพียงคลาสเดียว)

## Abstract classes — คลาสฐานบางส่วน (สร้าง instance ไม่ได้)

```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 (คลาสลูกต้อง implement) กับโค้ดที่ใช้ร่วมกันแบบ concrete เป็นคลาสฐานที่สร้าง instance โดยตรงไม่ได้

## Interfaces — สัญญาล้วน ๆ (มีได้หลายอัน)

```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** นิยามสัญญา (เฉพาะ signature ของเมธอด ไม่มี implementation) คลาสสามารถ `implement` interface ได้ **หลายอัน** ซึ่งเป็นวิธีของ PHP ในการเลี่ยงข้อจำกัด single inheritance เพื่อแบ่งปันความสามารถ

## เมื่อไรควรใช้อะไร

```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 class และ interface เป็นเครื่องมือหลักของ OOP และการเข้าใจความแตกต่างมีความสำคัญต่อการออกแบบแอปพลิเคชัน PHP ที่มีโครงสร้างดี (และต่อการทำงานกับเฟรมเวิร์กที่พึ่งพาสิ่งเหล่านี้อย่างมาก) **Inheritance** (`extends`) ให้การใช้โค้ดซ้ำผ่านความสัมพันธ์แบบ "is-a" แต่ PHP อนุญาตเพียง single inheritance **Abstract class** ให้คลาสฐานที่ใช้ร่วมกันซึ่งมีทั้งโค้ดที่ implement แล้วและเมธอดที่คลาสลูกต้องนิยาม เหมาะกับคลาสที่เกี่ยวข้องใกล้ชิดกันที่แบ่งปันตรรกะ **Interface** นิยามสัญญา/ความสามารถ และที่สำคัญคือคลาสสามารถ implement ได้ **หลายอัน** ทำให้ interface เป็นกุญแจสำคัญของการออกแบบที่ยืดหยุ่นและ decoupled และเป็นคำตอบของ PHP ต่อข้อจำกัด single inheritance

การรู้ว่าเมื่อไรควรใช้แต่ละอย่าง (inheritance สำหรับการใช้ซ้ำแบบ is-a, abstract class สำหรับ implementation บางส่วนที่ใช้ร่วมกัน, interface สำหรับสัญญา/ความสามารถ) และหลักการ **programming to interfaces** (พึ่งพา abstraction เพื่อให้โค้ดทดสอบได้ ยืดหยุ่น และเข้ากับเฟรมเวิร์ก) เป็นความรู้สำคัญสำหรับการออกแบบ PHP เชิงวัตถุ

กลไกเหล่านี้เป็นรากฐานของวิธีที่เฟรมเวิร์กอย่าง Laravel และ Symfony จัดโครงสร้างโค้ด (มี interface และ abstract base class อยู่ทุกที่) ทำให้มันจำเป็นทั้งต่อการออกแบบโค้ดของคุณเองให้ดีและการเข้าใจเฟรมเวิร์กที่คุณสร้างบนนั้น