PHP การสืบทอดและ abstract class



การสืบทอด (inheritance) ใช้เมื่อคลาสหนึ่ง “เป็นชนิดหนึ่งของ” อีกคลาส เช่น Admin เป็นชนิดหนึ่งของ User

extends — รับมรดกจากคลาสแม่

<?php
declare(strict_types=1);

class User
{
    public function __construct(
        public string $name,
        public string $email,
    ) {}

    public function describe(): string
    {
        return "ผู้ใช้: {$this->name} <{$this->email}>";
    }
}

class Admin extends User
{
    public function __construct(
        string $name,
        string $email,
        public array $permissions = [],
    ) {
        parent::__construct($name, $email);
    }

    public function can(string $permission): bool
    {
        return in_array($permission, $this->permissions, true);
    }
}

$admin = new Admin('สมชาย', 'somchai@example.com', ['delete', 'ban']);
echo $admin->describe(), "\n";           // ใช้เมธอดจากแม่ได้เลย
var_dump($admin->can('ban'));            // true
var_dump($admin instanceof User);        // true — Admin เป็น User
  • Admin extends User — Admin ได้ property และ method ของ User มาทั้งหมด
  • parent::__construct(...) — เรียก constructor ของแม่ ต้องเรียกเองถ้าลูกมี constructor ของตัวเอง
  • $admin instanceof User เป็น true — ตรงนี้สำคัญ ฟังก์ชันที่รับ User รับ Admin ได้

override — เขียนเมธอดทับของแม่

<?php
class Admin extends User
{
    // ... constructor เดิม ...

    public function describe(): string
    {
        $base = parent::describe();       // เอาของแม่มาต่อยอด
        return $base . ' [ผู้ดูแลระบบ]';
    }
}

echo (new Admin('อร', 'orn@example.com'))->describe(), "\n";
// ผู้ใช้: อร <orn@example.com> [ผู้ดูแลระบบ]

เมธอดที่ override ต้อง เข้ากันได้ กับของแม่ (พารามิเตอร์ และ return type ไม่ขัดกัน) ตั้งแต่ PHP 8.3 ใส่ attribute #[\Override] เพื่อให้ PHP ตรวจว่าเรากำลัง override จริง (กันพิมพ์ชื่อเมธอดผิด):

<?php
class Admin extends User
{
    #[\Override]
    public function describe(): string
    {
        return parent::describe() . ' [ผู้ดูแลระบบ]';
    }
}

final — ห้ามสืบทอด/override ต่อ

<?php
final class Password        // ห้ามมีคลาสลูก
{
    // ...
}

class Service
{
    final public function id(): string   // ลูก override เมธอดนี้ไม่ได้
    {
        return 'svc-001';
    }
}

ใช้ final เมื่ออยากรับประกันว่าพฤติกรรมตรงนี้จะไม่ถูกเปลี่ยนโดยคลาสลูก — หลายทีมตั้งเป็นค่าเริ่มต้นว่า “คลาสเป็น final ไว้ก่อน เปิดให้สืบทอดเมื่อออกแบบมาเพื่อการนั้น”

abstract class — แม่พิมพ์ที่สร้างอ็อบเจกต์เองไม่ได้

abstract class เอาไว้เป็นฐานร่วมเท่านั้น สร้าง new ตรง ๆ ไม่ได้ และมี abstract method ที่บอกแค่ลายเซ็น บังคับให้คลาสลูกทุกตัวต้อง implement:

<?php
declare(strict_types=1);

abstract class Shape
{
    abstract public function area(): float;

    // เมธอดปกติก็มีได้ ใช้ area() ที่ลูกจะ implement
    public function describe(): string
    {
        return sprintf('%s พื้นที่ %.2f', static::class, $this->area());
    }
}

class Circle extends Shape
{
    public function __construct(private float $radius) {}

    public function area(): float
    {
        return pi() * $this->radius ** 2;
    }
}

class Square extends Shape
{
    public function __construct(private float $side) {}

    public function area(): float
    {
        return $this->side ** 2;
    }
}

$shapes = [new Circle(3), new Square(4)];
foreach ($shapes as $shape) {
    echo $shape->describe(), "\n";
}
// Circle พื้นที่ 28.27
// Square พื้นที่ 16.00

// $x = new Shape();   // Error: Cannot instantiate abstract class Shape

Shape รวม “สิ่งที่ทุกรูปทรงทำเหมือนกัน” (describe()) ไว้ที่เดียว ส่วน “สิ่งที่ต่างกัน” (area()) บังคับให้ลูกเติม ถ้า Circle ลืม implement area() จะ error ตอนโหลดคลาส ไม่ใช่ตอนรัน

เมื่อไรใช้สืบทอด เมื่อไรไม่ใช้

ใช้เมื่อความสัมพันธ์เป็น “is-a” จริง ๆ และคลาสลูกใช้แทนคลาสแม่ได้ทุกที่ ถ้าแค่อยาก “ใช้โค้ดซ้ำ” ให้พิจารณา:

  • composition — ให้คลาสถืออ็อบเจกต์อีกตัวไว้เป็น property แล้วเรียกใช้ (ยืดหยุ่นกว่า)
  • trait — แชร์เมธอดข้ามคลาสที่ไม่เกี่ยวกัน (บทหน้า)
  • interface — กำหนดสัญญาโดยไม่ผูกโค้ด (บทถัดไป)

หลักที่ยึดกันคือ “prefer composition over inheritance” — การสืบทอดหลายชั้นทำให้ตามยากว่าเมธอดจริงมาจากไหน

เรื่องที่คนมักพลาด

  • ลืมเรียก parent::__construct() เมื่อลูกมี constructor เอง — property ของแม่จะไม่ถูกตั้งค่า
  • override เมธอดแล้วเปลี่ยน signature จนขัดกับแม่ เช่น เพิ่มพารามิเตอร์บังคับ — PHP เตือน/error เพราะละเมิด Liskov
  • สืบทอดเพื่อ reuse โค้ดทั้งที่ไม่ใช่ is-a เช่น class Invoice extends Array — ใช้ composition แทน
  • สร้างลำดับชั้นลึก 4–5 ชั้น ตามโค้ดว่าเมธอดจริงมาจากไหนแทบไม่ไหว — ตื้นไว้ดีกว่า
  • self:: กับ static:: ในคลาสแม่ — self::class คืนชื่อคลาสแม่เสมอ, static::class คืนชื่อคลาสลูกที่เรียกจริง (late static binding, บทที่ 20)
  • private method ของแม่แล้วคิดว่าลูก override ได้ — private มองไม่เห็นจากลูก ลูกจะสร้างเมธอดใหม่คนละตัว ใช้ protected ถ้าตั้งใจให้ลูกทับ

สรุป

  • class B extends A — B ได้ property/method ของ A, B instanceof A เป็น true
  • parent::method() เรียกของแม่, override ด้วยชื่อเมธอดเดิม (ใส่ #[\Override] ให้ PHP ตรวจ)
  • final ห้ามสืบทอด/override ต่อ
  • abstract class สร้างเองไม่ได้ ใช้เป็นฐานร่วม, abstract method บังคับให้ลูก implement
  • ใช้สืบทอดเมื่อเป็น “is-a” จริง ๆ ไม่งั้นเลือก composition / trait / interface

บทถัดไปว่าด้วย interface — การกำหนด “สัญญา” ว่าคลาสต้องมีเมธอดอะไรบ้าง โดยไม่ผูกโค้ด และทำให้ polymorphism ทำงาน