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 เป็น UserAdmin 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 ShapeShape รวม “สิ่งที่ทุกรูปทรงทำเหมือนกัน” (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)privatemethod ของแม่แล้วคิดว่าลูก override ได้ —privateมองไม่เห็นจากลูก ลูกจะสร้างเมธอดใหม่คนละตัว ใช้protectedถ้าตั้งใจให้ลูกทับ
สรุป
class B extends A— B ได้ property/method ของ A,B instanceof Aเป็น trueparent::method()เรียกของแม่, override ด้วยชื่อเมธอดเดิม (ใส่#[\Override]ให้ PHP ตรวจ)finalห้ามสืบทอด/override ต่อabstract classสร้างเองไม่ได้ ใช้เป็นฐานร่วม,abstract methodบังคับให้ลูก implement- ใช้สืบทอดเมื่อเป็น “is-a” จริง ๆ ไม่งั้นเลือก composition / trait / interface
บทถัดไปว่าด้วย interface — การกำหนด “สัญญา” ว่าคลาสต้องมีเมธอดอะไรบ้าง โดยไม่ผูกโค้ด และทำให้ polymorphism ทำงาน