Polymorphism là gì? Các bài nghiên cứu khoa học liên quan

Định nghĩa polymorphism

Polymorphism là một khái niệm nền tảng trong khoa học máy tính và lập trình hướng đối tượng, biểu thị khả năng của một thực thể—có thể là hàm, đối tượng hoặc lớp—có thể tồn tại hoặc vận hành theo nhiều hình thức khác nhau. Từ “polymorphism” bắt nguồn từ tiếng Hy Lạp: “poly” nghĩa là “nhiều” và “morph” nghĩa là “hình dạng”, phản ánh bản chất linh hoạt và mở rộng của khái niệm này trong ngữ cảnh lập trình.

Trong lập trình hướng đối tượng (OOP), polymorphism cho phép một giao diện (interface) thống nhất có thể được thực hiện bởi nhiều lớp khác nhau, hoặc cho phép một phương thức có thể xử lý nhiều kiểu dữ liệu khác nhau. Điều này tạo điều kiện thuận lợi cho việc mở rộng hệ thống, tăng tính tái sử dụng mã và giảm phụ thuộc vào các triển khai cụ thể. Tính đa hình cũng hỗ trợ viết các chương trình tổng quát hơn, dễ bảo trì hơn và có khả năng tương thích với nhiều kiểu dữ liệu mới trong tương lai mà không cần sửa đổi cấu trúc hiện có.

Polymorphism là một trong bốn trụ cột chính của OOP, bên cạnh tính đóng gói (encapsulation), tính kế thừa (inheritance) và tính trừu tượng (abstraction). Trong thực tế, nó được triển khai rộng rãi trong nhiều ngôn ngữ lập trình hiện đại như Java, C++, Python, C#, Rust và Haskell. Tài liệu tham khảo chi tiết từ Oracle: Oracle Java Polymorphism Guide.

Phân loại polymorphism

Polymorphism trong lập trình được phân thành hai nhóm chính dựa trên thời điểm quyết định hành vi của chương trình: polymorphism tĩnh (compile-time polymorphism) và polymorphism động (runtime polymorphism). Cả hai loại đều hướng đến mục tiêu hỗ trợ khả năng “đa hình” trong hành vi chương trình, nhưng có sự khác biệt căn bản về cách triển khai và sử dụng.

Bảng phân biệt hai loại polymorphism:

Tiêu chí	Polymorphism tĩnh	Polymorphism động
Thời điểm quyết định hành vi	Trong quá trình biên dịch	Trong quá trình thực thi
Cách triển khai	Nạp chồng phương thức/toán tử	Ghi đè phương thức, interface
Hiệu suất	Cao hơn	Chậm hơn do dynamic dispatch
Khả năng mở rộng	Hạn chế hơn	Linh hoạt hơn

Polymorphism tĩnh thường dễ triển khai và kiểm soát hơn, nhưng polymorphism động lại cung cấp nhiều lợi thế về mặt mở rộng hệ thống, đặc biệt khi làm việc với kiến trúc plugin hoặc giao diện lập trình ứng dụng (API) hướng giao diện. Cả hai hình thức đều có vai trò thiết yếu trong thiết kế phần mềm linh hoạt và bền vững.

Polymorphism tĩnh

Polymorphism tĩnh, hay còn gọi là compile-time polymorphism, là dạng đa hình trong đó quyết định về phương thức được thực hiện trong quá trình biên dịch. Hai cơ chế phổ biến để hiện thực polymorphism tĩnh là nạp chồng phương thức (method overloading) và nạp chồng toán tử (operator overloading).

Nạp chồng phương thức cho phép khai báo nhiều hàm có cùng tên nhưng khác nhau về kiểu hoặc số lượng tham số. Trình biên dịch sẽ chọn hàm phù hợp dựa trên chữ ký hàm tại thời điểm biên dịch. Ví dụ trong Java:

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
}

Ba phương thức `add` có cùng tên nhưng được phân biệt dựa trên kiểu và số lượng tham số đầu vào.

Nạp chồng toán tử thường thấy trong C++, cho phép định nghĩa lại cách thức hoạt động của các toán tử với kiểu dữ liệu do người dùng định nghĩa. Ví dụ, toán tử `+` có thể được định nghĩa lại để cộng hai đối tượng `Vector`:

Vector operator+(const Vector& a, const Vector& b) {
    return Vector(a.x + b.x, a.y + b.y);
}

Polymorphism tĩnh giúp tăng khả năng biểu đạt và giảm trùng lặp mã nguồn khi cần thao tác với nhiều kiểu dữ liệu khác nhau nhưng logic xử lý tương tự.

Polymorphism động

Polymorphism động, hay runtime polymorphism, cho phép quyết định hành vi cụ thể của đối tượng trong lúc thực thi. Cơ chế này chủ yếu được thực hiện thông qua ghi đè phương thức (method overriding) trong mối quan hệ kế thừa giữa lớp cha và lớp con. Khi một lớp con định nghĩa lại một phương thức của lớp cha, trình biên dịch sẽ chọn phương thức thực thi phù hợp tại thời điểm chạy thông qua dynamic dispatch.

Ví dụ trong Java:

class Animal {
    void makeSound() { System.out.println("Some sound"); }
}
class Cat extends Animal {
    void makeSound() { System.out.println("Meow"); }
}

Animal a = new Cat(); a.makeSound(); sẽ in ra "Meow", mặc dù biến `a` được khai báo kiểu `Animal`, nhờ cơ chế đa hình động.

Trong Python, polymorphism động được thực hiện thông qua duck typing: "Nếu nó đi như vịt, kêu như vịt thì ta coi nó là vịt." Không cần quan tâm đến lớp cụ thể của đối tượng, miễn là nó có phương thức phù hợp. Điều này cho phép các hàm trong Python xử lý đối tượng đa dạng mà không cần định nghĩa rõ ràng kiểu dữ liệu:

def describe(obj):
    obj.describe()

Miễn là `obj` có phương thức `describe()`, hàm sẽ hoạt động, bất kể `obj` là lớp nào.

Polymorphism trong lập trình hàm

Trong lập trình hàm, polymorphism được triển khai chủ yếu dưới hình thức polymorphism tham số (parametric polymorphism) và polymorphism phụ thuộc kiểu (ad-hoc polymorphism). Parametric polymorphism cho phép định nghĩa các hàm hoặc cấu trúc dữ liệu hoạt động trên mọi kiểu đầu vào mà không cần chỉ định cụ thể, giúp tăng khả năng tái sử dụng và trừu tượng hóa logic chương trình.

Ví dụ điển hình trong Haskell:

identity :: a -> a
identity x = x

Hàm `identity` có thể nhận bất kỳ kiểu dữ liệu nào và trả về đúng kiểu đó, vì `a` là một tham số kiểu (type variable). Khả năng này cũng được hỗ trợ trong Scala, Rust (thông qua generics) và C++ (templates). Các hàm polymorphic có thể hoạt động thống nhất với nhiều kiểu mà không cần định nghĩa lại.

Ad-hoc polymorphism, ngược lại, yêu cầu định nghĩa cụ thể cách hàm hoạt động với từng kiểu dữ liệu khác nhau thông qua overloading hoặc type classes. Trong Haskell, type class là một cơ chế mạnh mẽ để định nghĩa các hành vi polymorphic:

class Eq a where
    (==) :: a -> a -> Bool

Các kiểu cụ thể như Int, Char, List phải định nghĩa cách so sánh bằng nhau để được xem là thành viên của type class `Eq`. Điều này mở rộng khả năng polymorphism một cách linh hoạt, nhưng vẫn đảm bảo an toàn kiểu tĩnh.

Lợi ích của polymorphism

Polymorphism không chỉ là một kỹ thuật lập trình, mà còn là nền tảng của thiết kế phần mềm hướng đối tượng và hàm hiện đại. Lợi ích nổi bật nhất là khả năng tổng quát hóa và tái sử dụng mã. Một đoạn mã có thể áp dụng cho nhiều kiểu dữ liệu khác nhau, giảm số lượng mã cần viết và kiểm thử.

Polymorphism hỗ trợ mạnh mẽ cho các nguyên tắc thiết kế SOLID, đặc biệt là nguyên tắc mở rộng-mở (Open/Closed Principle) và nguyên tắc thay thế Liskov (Liskov Substitution Principle). Khi một lớp con có thể thay thế lớp cha mà không làm thay đổi hành vi hệ thống, polymorphism giúp đảm bảo tính ổn định và dễ mở rộng của phần mềm.

Lợi ích cụ thể:

• Giảm sự phụ thuộc vào các lớp cụ thể: Code làm việc với interface hoặc lớp trừu tượng thay vì triển khai cụ thể.
• Tăng tính mô-đun: Cho phép thay thế hoặc mở rộng chức năng mà không cần thay đổi code gốc.
• Hỗ trợ kiểm thử đơn vị: Có thể dùng các đối tượng mock có hành vi polymorphic trong unit test.

Việc sử dụng polymorphism hiệu quả giúp kiến trúc phần mềm bền vững và dễ thích nghi hơn trong môi trường thay đổi liên tục.

Polymorphism và các nguyên lý OOP khác

Polymorphism không tồn tại độc lập, mà được hỗ trợ và liên kết chặt chẽ với các đặc điểm khác của lập trình hướng đối tượng. Kế thừa là nền tảng cho polymorphism động: lớp con kế thừa từ lớp cha và có thể ghi đè các phương thức để thay đổi hành vi. Trừu tượng hóa là công cụ thiết kế giúp mô tả hành vi mong muốn mà không quan tâm đến cách thức thực hiện cụ thể.

Khi lập trình theo interface (giao diện), người phát triển chỉ quan tâm đến các hành vi mà lớp phải có, bất kể lớp đó thực thi như thế nào. Điều này cho phép viết code theo kiểu:

void processShape(Shape s) {
    s.draw();
}

Mọi lớp thực hiện `Shape` như `Circle`, `Square`, `Polygon` đều có thể truyền vào mà không cần viết lại hàm `processShape`.

Sự kết hợp giữa kế thừa, trừu tượng và đa hình tạo thành một tam giác thiết kế mạnh mẽ trong OOP, cho phép mô hình hóa các hệ thống phức tạp một cách tự nhiên, linh hoạt và có tổ chức hơn.

Polymorphism trong các ngôn ngữ lập trình

Polymorphism được hiện thực rộng rãi trong hầu hết các ngôn ngữ hiện đại, nhưng cách thức triển khai có thể khác nhau. Trong Java, polymorphism động là chuẩn, dựa trên kế thừa và interface. C++ mở rộng khả năng với cả polymorphism động và tĩnh, đồng thời hỗ trợ nạp chồng toán tử. Python sử dụng duck typing thay vì khai báo kiểu tường minh.

C# sử dụng từ khóa `virtual` và `override` để quản lý đa hình động. Rust hỗ trợ polymorphism thông qua generics và trait objects, với các ràng buộc kiểu giúp duy trì tính an toàn bộ nhớ. Swift, Go và Kotlin cũng có các cơ chế polymorphism riêng biệt phù hợp với mô hình lập trình của từng ngôn ngữ.

So sánh một số điểm khác biệt:

Ngôn ngữ	Hình thức polymorphism	Ghi chú
Java	Động & tĩnh	Interface là công cụ chính
C++	Động, tĩnh & nạp chồng toán tử	Hỗ trợ sâu qua vtable
Python	Động (duck typing)	Không yêu cầu khai báo kiểu
Haskell	Tham số & ad-hoc	Sử dụng type classes

Polymorphism và hiệu năng

Dù polymorphism mang lại lợi ích thiết kế lớn, nhưng cũng có thể ảnh hưởng đến hiệu suất, đặc biệt là polymorphism động. Khi gọi phương thức ảo, trình biên dịch không thể inline mã do không biết chính xác phương thức nào sẽ được gọi tại thời điểm biên dịch. Thay vào đó, hệ thống runtime phải tra cứu bảng hàm ảo (vtable) để xác định phương thức thích hợp.

Trong các hệ thống nhúng hoặc ứng dụng đòi hỏi hiệu năng cực cao, polymorphism có thể bị hạn chế hoặc thay thế bằng các kỹ thuật khác như template metaprogramming (C++) hoặc monomorphization (Rust) để tối ưu hóa hiệu năng. Tuy nhiên, các trình biên dịch hiện đại như JVM, .NET CLR hay LLVM đã hỗ trợ nhiều tối ưu hoá như JIT inlining, branch prediction để giảm thiểu chi phí thực thi polymorphism.

Sự đánh đổi giữa hiệu suất và tính linh hoạt là một phần không thể tách rời trong thiết kế phần mềm. Polymorphism nên được sử dụng có chọn lọc trong các vị trí mà lợi ích về mở rộng và tái sử dụng lớn hơn so với chi phí về hiệu năng.

Tóm tắt

Polymorphism là khả năng cho phép các đối tượng, hàm hoặc cấu trúc trong lập trình biểu hiện hành vi khác nhau dưới cùng một giao diện. Đây là công cụ thiết kế quan trọng trong cả lập trình hướng đối tượng lẫn lập trình hàm, hỗ trợ mở rộng, tái sử dụng mã và viết phần mềm linh hoạt, dễ bảo trì trong môi trường phát triển phức tạp và thay đổi liên tục.