Kế thừa, abstract class và interface hoạt động như thế nào?

Question

Accepted Answer

PHP hỗ trợ kế thừa và trừu tượng hóa OOP qua ba cơ chế liên quan: **kế thừa class** (`extends`), **abstract class** (lớp cơ sở một phần), và **interface** (hợp đồng). Mỗi cái phục vụ một mục đích thiết kế khác nhau.

## Kế thừa — mở rộng một lớp cha

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog kế thừa các thành viên của Animal
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // ghi đè
        return parent::eat() . " noisily";   // parent:: gọi method của lớp cha
    }
}
```

Một lớp con `extends` một lớp cha, kế thừa và tùy chọn ghi đè các thành viên của nó. `parent::` gọi method cha đã bị ghi đè. PHP hỗ trợ **kế thừa đơn** (chỉ một cha).

## Abstract class — một lớp cơ sở một phần (không thể tạo instance)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — lớp con BẮT BUỘC triển khai
    public function describe(): string {         // concrete — code dùng chung
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // phải triển khai
}
// new Shape();  // ❌ lỗi — abstract class không thể tạo instance
```

Một **abstract class** trộn các method abstract (lớp con phải triển khai) với code dùng chung cụ thể — một lớp cơ sở không thể tạo instance trực tiếp.

## Interface — hợp đồng thuần túy (cho phép nhiều)

```php
interface Drawable {
    public function draw(): void;       // chỉ chữ ký — không có triển khai
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // triển khai NHIỀU interface
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

Một **interface** định nghĩa một hợp đồng (các chữ ký method, không triển khai). Một class có thể `implement` **nhiều** interface — cách của PHP để vượt qua hạn chế kế thừa đơn cho việc chia sẻ năng lực.

## Khi nào dùng cái nào

```text
extends (kế thừa) → quan hệ "is-a", tái sử dụng + ghi đè hành vi
abstract class → một lớp cơ sở với code DÙNG CHUNG + method lớp con phải triển khai (đơn)
interface → một HỢP ĐỒNG/năng lực mà nhiều class không liên quan có thể đáp ứng (nhiều)
→ "Lập trình hướng interface" — phụ thuộc vào interface để có thiết kế linh hoạt, dễ test.
```

## Tại sao điều này quan trọng

Kế thừa, abstract class và interface là các công cụ OOP cốt lõi, và hiểu sự phân biệt giữa chúng quan trọng để thiết kế ứng dụng PHP có cấu trúc tốt (và để làm việc với các framework, vốn dựa rất nhiều vào những thứ này). **Kế thừa** (`extends`) mang lại tái sử dụng code qua quan hệ "is-a", nhưng PHP chỉ cho phép kế thừa đơn. **Abstract class** cung cấp một lớp cơ sở dùng chung với cả code đã triển khai lẫn method lớp con phải định nghĩa — phù hợp cho các class liên quan chặt chẽ chia sẻ logic. **Interface** định nghĩa hợp đồng/năng lực, và quan trọng là một class có thể triển khai **nhiều** interface — khiến interface là chìa khóa cho thiết kế linh hoạt, ít ràng buộc và là lời đáp của PHP cho hạn chế kế thừa đơn.

Biết khi nào dùng mỗi cái (kế thừa cho tái sử dụng is-a, abstract class cho triển khai một phần dùng chung, interface cho hợp đồng/năng lực), và nguyên tắc **lập trình hướng interface** (phụ thuộc vào trừu tượng để có code dễ test, linh hoạt, thân thiện với framework), là kiến thức quan trọng cho thiết kế PHP hướng đối tượng.

Các cơ chế này làm nền cho cách các framework như Laravel và Symfony cấu trúc code của chúng (interface và abstract base class ở khắp nơi), khiến chúng thiết yếu cho cả việc thiết kế code của bạn tốt lẫn hiểu các framework bạn xây dựng trên đó.