PHP Tutorial

[Video] Kế thừa OOP - Lập trình php

Mở bài

Kế thừa là một trong những khái niệm cốt lõi của hướng đối tượng — và trong ngữ cảnh Kế thừa OOP - Lập trình php, nó giúp lập trình viên tổ chức mã nguồn theo cách dễ đọc, dễ mở rộng và ít lỗi hơn. Khi bạn viết ứng dụng nhỏ bằng PHP và muốn phát triển thành hệ thống lớn, hiểu rõ kế thừa không chỉ giúp tái sử dụng mã (reuse) mà còn mở đường cho các nguyên tắc thiết kế như SOLID, giảm thiểu sự trùng lặp và tăng tính ổn định của dự án.

Bài viết này đi sâu vào Kế thừa OOP - Lập trình php: từ định nghĩa cơ bản, cú pháp, các tình huống thực tế, đến những anti-pattern cần tránh. Tôi sẽ minh họa bằng ví dụ cụ thể, so sánh với các kỹ thuật khác như composition, interface và trait để bạn biết khi nào nên dùng kế thừa và khi nào nên chọn giải pháp khác. Nếu bạn đang học PHP hướng đối tượng hoặc muốn refactor code procedural sang OOP, đọc kỹ bài này sẽ giúp bạn hiểu rõ cách áp dụng kế thừa một cách an toàn và thực tế.

Kế thừa là gì và vai trò trong OOP (Kế thừa OOP - Lập trình php)

Kế thừa (inheritance) là phép mô tả mối quan hệ “là một” (is-a) giữa các lớp: một lớp con có thể thừa hưởng thuộc tính và phương thức từ lớp cha. Trong thực tế của Kế thừa OOP - Lập trình php, ta thường khai báo class Child extends Parent để hưởng lại logic cơ bản và chỉ ghi đè (override) hoặc mở rộng phương thức khi cần.

Vai trò chính của kế thừa:

Tái sử dụng mã: bạn viết logic chung ở lớp cha, lớp con dùng lại mà không lặp lại.
Tổ chức biểu diễn domain: mô tả quan hệ thực tế như Employee là một Person.
Hỗ trợ đa hình (polymorphism): code phía caller xử lý Person mà không biết đó là Student hay Teacher.

Trong bối cảnh Kế thừa OOP - Lập trình php, kế thừa giúp triển khai các mô hình theo domain rõ ràng: models, controllers, services... Tuy nhiên, cần cân nhắc vì lạm dụng kế thừa dễ tạo ra coupling mạnh giữa các lớp, gây khó khăn khi refactor. Thay vì dùng kế thừa cho mọi tình huống, hãy cân nhắc composition (has-a) khi quan hệ không phải là “là một”.

Lưu ý khi thiết kế: lớp cha nên chịu trách nhiệm duy nhất (Single Responsibility), giảm thiểu các phương thức “không liên quan” để lớp con không bị thừa nhận những trách nhiệm không cần thiết — đây là nguyên lý quan trọng khi áp dụng Kế thừa OOP - Lập trình php vào dự án thực tế.

Cú pháp kế thừa trong PHP và ví dụ cơ bản

PHP hỗ trợ kế thừa bằng từ khóa extends. Dưới đây là ví dụ minh họa phong cách chuẩn trong Kế thừa OOP - Lập trình php:


<?php
class Person {
    protected $name;
    protected $age;

    public function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }

    public function introduce() {
        return "Tôi là {$this->name}, tuổi {$this->age}.";
    }
}

class Student extends Person {
    private $studentId;

    public function __construct($name, $age, $studentId) {
        parent::__construct($name, $age);
        $this->studentId = $studentId;
    }

    public function introduce() {
        return parent::introduce() . " Mã SV: {$this->studentId}.";
    }
}

$sv = new Student('An', 20, 'SV001');
echo $sv->introduce();

Giải thích:

Student kế thừa Person, thừa hưởng thuộc tính $name, $age và phương thức introduce().
parent::__construct() gọi constructor của lớp cha để khởi tạo phần chung.
Student::introduce() override phương thức cha nhưng vẫn tái sử dụng bằng parent::introduce().

Trong Kế thừa OOP - Lập trình php, việc gọi parent:: là phổ biến khi bạn muốn thêm hành vi thay vì thay thế hoàn toàn. Lưu ý sử dụng protected cho các thuộc tính/ phương thức mà chỉ các lớp con cần truy cập — tránh đặt mọi thứ là public.

Ghi đè phương thức (override) và gọi phương thức cha

Ghi đè (method overriding) là khả năng lớp con định nghĩa lại phương thức cùng tên với lớp cha. Đây là cơ chế then chốt để mở rộng hành vi trong Kế thừa OOP - Lập trình php. Ví dụ ở trên minh họa override introduce().

Khi override, bạn có 3 lựa chọn:

Thay thế hoàn toàn: lớp con triển khai hành vi mới, không gọi parent::.
Mở rộng hành vi: lớp con gọi parent::method() rồi thêm logic.
Gọi trước hoặc sau: bạn có thể gọi parent::method() trước hoặc sau logic lớp con tùy ngữ cảnh.

Ví dụ khác: override xử lý lưu:


class Logger {
    public function log($msg) {
        // write to file
    }
}

class DbLogger extends Logger {
    public function log($msg) {
        parent::log($msg); // file
        // thêm vào db
    }
}

Chú ý: Khi bạn override một phương thức, hãy giữ interface (signature) tương thích để không phá vỡ Liskov Substitution Principle — điều này quan trọng khi áp dụng Kế thừa OOP - Lập trình php trong hệ thống lớn, nơi object của lớp con có thể được truyền vào hàm yêu cầu lớp cha.

Access modifiers: public, protected, private trong kế thừa

Trong Kế thừa OOP - Lập trình php, quyền truy cập (access modifier) quyết định phạm vi sử dụng của thuộc tính và phương thức:

public: truy cập từ mọi nơi (đối tượng, lớp con, ngoài package).
protected: truy cập từ lớp hiện tại và lớp kế thừa (con).
private: chỉ truy cập trong chính lớp khai báo (không cho lớp con).

Ví dụ:


class A {
    public $x;
    protected $y;
    private $z;
}

class B extends A {
    public function test() {
        echo $this->x; // OK
        echo $this->y; // OK
        echo $this->z; // Lỗi: không truy cập private
    }
}

Thiết kế tốt sẽ dùng private cho dữ liệu nội bộ thực sự không muốn lộ, protected cho thành phần mà lớp con cần truy cập. Nếu bạn nhận thấy lớp con phải truy cập nhiều thuộc tính private của cha, có thể đó là dấu hiệu của thiết kế sai — nên cân nhắc đưa logic vào method protected ở lớp cha để đóng gói (encapsulation).

Trong việc áp dụng Kế thừa OOP - Lập trình php, luôn ưu tiên private hoặc protected hơn public để bảo vệ invariants (tính bất biến) của class.

Abstract class, Interface và khi nào dùng kế thừa

PHP hỗ trợ abstract class và interface để định nghĩa hợp đồng. Sự khác biệt và ứng dụng liên quan chặt chẽ tới chiến lược kế thừa.

Abstract class: có thể chứa implement và abstract method. Lớp con extends abstract class và phải implement các method abstract. Dùng khi muốn cung cấp implementation mặc định cho một số hành vi chung.
Interface: chỉ định danh sách method mà lớp phải implement; PHP hỗ trợ implements nhiều interface (đa giao diện).

Ví dụ:


abstract class Animal {
    abstract public function sound();
    public function breathe() {
        // default
    }
}

interface Swimmable {
    public function swim();
}

class Dolphin extends Animal implements Swimmable {
    public function sound() { return 'click'; }
    public function swim() { return 'swimming'; }
}

Trong Kế thừa OOP - Lập trình php, hãy dùng abstract class khi muốn chia sẻ trạng thái/behavior; dùng interface để định nghĩa contract trừu tượng, đặc biệt khi muốn hỗ trợ đa dạng loại (ví dụ LoggerInterface để dùng nhiều implementation).

Một lưu ý quan trọng: PHP không hỗ trợ multiple inheritance (một lớp kế thừa nhiều lớp cha) nhưng có trait để trộn behavior. Trait giúp bạn tái sử dụng mã mà không phá vỡ cây kế thừa.

Traits và giới hạn của kế thừa: khi nào tránh dùng extends

Traits xuất hiện để khắc phục hạn chế kế thừa đơn. Trait cho phép tái sử dụng phương thức giữa các lớp không liên quan. Ví dụ:


trait Timestampable {
    public function createdAt() { ... }
    public function updatedAt() { ... }
}

class Post {
    use Timestampable;
}
class Comment {
    use Timestampable;
}

Lưu ý: Kế thừa OOP - Lập trình php rất hữu ích nhưng không phải lúc nào cũng là lựa chọn tốt. Hãy cân nhắc:

Nếu mô quan hệ không phải “is-a”, dùng composition (has-a).
Tránh cây kế thừa sâu quá — khó hiểu, dễ break.
Sử dụng trait để chia sẻ behavior chứ không để che giấu thiết kế kém.

Một anti-pattern hay gặp là lạm dụng kế thừa để tái sử dụng mã dẫn đến tight coupling. Thay vào đó, áp dụng composition hoặc interface để giữ code linh hoạt.

SOLID, Liskov và các nguyên tắc thiết kế liên quan đến kế thừa

Khi áp dụng Kế thừa OOP - Lập trình php, cần tuân thủ các nguyên tắc thiết kế để tránh rủi ro:

Single Responsibility (SRP): mỗi lớp chỉ có một trách nhiệm.
Open/Closed (OCP): lớp mở để mở rộng (inheritance hoặc composition) nhưng đóng để sửa đổi.
Liskov Substitution Principle (LSP): đối tượng con có thể thay thế cha mà không làm thay đổi tính đúng đắn của chương trình. Tránh sửa đổi contract của phương thức khi override.
Interface Segregation (ISP): interface nên nhỏ và chuyên biệt.
Dependency Inversion (DIP): phụ thuộc vào abstraction (interface), không phụ thuộc vào concrete.

Nguyên tắc LSP đặc biệt liên quan tới kế thừa: nếu bạn làm lớp con trả lỗi hoặc thay đổi hành vi không tương thích, bạn phá vỡ LSP, gây lỗi khó debug khi dùng polymorphism.

Ví dụ thực tế: mô hình nhân viên (Employee) và quản lý (Manager)

Một ví dụ ứng dụng Kế thừa OOP - Lập trình php trong system:


class Employee {
    protected $name;
    protected $salary;
    public function __construct($name, $salary) {
        $this->name = $name; $this->salary = $salary;
    }
    public function getPay() {
        return $this->salary;
    }
}

class Manager extends Employee {
    private $bonus;
    public function __construct($name, $salary, $bonus) {
        parent::__construct($name, $salary);
        $this->bonus = $bonus;
    }
    public function getPay() {
        return parent::getPay() + $this->bonus;
    }
}

Ở đây Manager là một Employee (is-a). Ta override getPay() để cộng thêm bonus. Khi viết code xử lý thanh toán, bạn có thể gọi getPay() với mảng Employee chứa Manager và Staff mà không cần phân biệt — minh họa đa hình.

Tuy nhiên nếu Manager có nhiều behavior hoàn toàn khác (ví dụ manageTeam() chứa logic rất khác), hãy cân nhắc trừu tượng hoá ra ICanManage interface thay vì ép tất cả logic vào cây kế thừa.

Debugging, testing và refactor khi dùng kế thừa

Khi hệ thống lớn, kế thừa dễ sinh bug do coupling. Một số phương pháp:

Viết Unit Test cho mỗi lớp để đảm bảo hành vi khi override không phá vỡ contract.
Refactor dần: tách logic chung vào lớp cha hoặc trait, giữ interface ổn định.
Sử dụng static analysis (PHPStan, Psalm) để phát hiện violation của LSP hoặc sai kiểu.
Document contract bằng PHPDoc để đồng đội hiểu yêu cầu method.

Việc chăm chỉ test và refactor giúp bạn áp dụng Kế thừa OOP - Lập trình php an toàn trong dự án thực tế.

Kết luận

Kế thừa là kỹ thuật mạnh mẽ trong OOP và khi áp dụng đúng, Kế thừa OOP - Lập trình php giúp bạn xây dựng mã nguồn sạch, dễ mở rộng và dễ bảo trì. Tuy nhiên, kế thừa cần được dùng có cân nhắc: ưu tiên SRP, tôn trọng Liskov Substitution Principle, và biết lúc nào nên dùng composition, interface hoặc trait thay vì ép cây kế thừa sâu.

Bắt đầu từ các ví dụ nhỏ — models, services, hoặc các lớp utility — và dần dần refactor code procedural sang các lớp có trách nhiệm rõ ràng. Đồng thời sử dụng PHPUnit, static analysis và code review để đảm bảo các lớp con tuân thủ hợp đồng lớp cha. Khi bạn thành thạo Kế thừa OOP - Lập trình php, việc chuyển sang các framework hiện đại như Laravel hay Symfony sẽ trở nên tự nhiên và hiệu quả. Hãy thực hành ngay: viết một vài lớp, tạo lớp con, ghi đè phương thức và thử nghiệm mọi trường hợp — đó là con đường nhanh nhất để làm chủ kế thừa trong PHP.

Mục Lục