TL;DR: Lập trình hướng đối tượng (Object-Oriented Programming - OOP) là cách tổ chức code quanh các đối tượng - mỗi đối tượng gói chung dữ liệu (thuộc tính) và hành vi (phương thức) tác động lên dữ liệu đó. Bốn trụ cột thường được nhắc tới là đóng gói (encapsulation), kế thừa (inheritance), đa hình (polymorphism) và trừu tượng (abstraction). Mục tiêu không phải "cho sang" mà là kiểm soát độ phức tạp khi hệ thống lớn dần.
Bạn viết một hàm tính lương. Rồi thêm hàm tính thưởng, hàm tính thuế, hàm xuất bảng lương... Mỗi hàm đều nhận vào một mớ tham số
ho_ten, luong_co_ban, so_ngay_cong, phu_cap. Đến khi cần thêm một trường mới, bạn phải sửa chữ ký của cả chục hàm. Càng lớn, code càng rối như mớ dây tai nghe trong túi.OOP ra đời để trị đúng cái mớ dây đó. Trong bài này tôi sẽ giải thích OOP thực sự là gì, bốn tính chất cốt lõi, kèm code Python chạy được và ví von đời thường cho từng cái. Không "đơn giản như ăn kẹo", nhưng cũng không đáng sợ.
OOP là gì?
Lập trình hướng đối tượng là một hướng tiếp cận (paradigm) tổ chức chương trình quanh các đối tượng (object) thay vì quanh các hàm và logic rời rạc. Mỗi đối tượng là một thực thể gói chung hai thứ:
- Thuộc tính (attributes / fields): dữ liệu mô tả trạng thái - ví dụ một
TaiKhoancóso_du,chu_tai_khoan. - Phương thức (methods): các hàm gắn với đối tượng, thao tác lên chính dữ liệu của nó - ví dụ
nap_tien(),rut_tien().
Ta định nghĩa khuôn mẫu bằng lớp (class), rồi tạo ra các thể hiện (instance) cụ thể từ khuôn đó. Class giống bản thiết kế ngôi nhà; mỗi ngôi nhà xây thật là một instance.
Ví von: hãy nghĩ tới viên LEGO. Mỗi viên là một object có đặc điểm riêng (màu, kích thước) và cách ghép nối riêng (các chấm mộng). Bạn không cần biết bên trong nhựa được đúc thế nào - cứ ghép là ra công trình. OOP cho bạn những "viên LEGO phần mềm" như vậy.
Vì sao cần OOP?
Với chương trình nhỏ, viết hàm thuần (procedural) là đủ và thường còn gọn hơn. Vấn đề xuất hiện khi hệ thống lớn dần: dữ liệu và hàm nằm rải rác, ai cũng sửa được mọi thứ, một thay đổi nhỏ kéo theo lỗi ở chỗ không ngờ.
OOP gom dữ liệu và hành vi liên quan về một chỗ, dựng ranh giới rõ ràng giữa "bên trong" và "bên ngoài". Nhờ đó:
- Dễ bảo trì: muốn hiểu tài khoản hoạt động ra sao, bạn đọc đúng một class.
- Tái sử dụng: một class viết tốt dùng lại được ở nhiều nơi.
- Dễ mở rộng: thêm loại mới mà ít phải đụng vào code cũ.
- Làm việc nhóm: mỗi người phụ trách một nhóm class với ranh giới rõ.
Lưu ý: OOP không phải "chân lý tối thượng". Nhiều bài toán hợp với lập trình hàm (functional) hơn, và lạm dụng kế thừa sâu là một trong những cách chắc chắn khiến code khó bảo trì. OOP là một công cụ, không phải cây đũa thần.
Bốn tính chất cốt lõi của OOP
Người ta thường tóm OOP vào bốn tính chất. Tôi sẽ đi từng cái, kèm code chạy được và một ví von.
1. Tính đóng gói (Encapsulation)
Đóng gói là gom dữ liệu và các phương thức thao tác lên nó vào chung một đơn vị, đồng thời che giấu trạng thái nội bộ và chỉ cho truy cập qua "cửa" đã kiểm soát. Nhờ vậy, không ai sửa bậy dữ liệu để đưa đối tượng về trạng thái vô lý (ví dụ số dư âm).
Ví von: cây ATM. Bạn rút tiền qua khe và bàn phím - những "cửa" hợp lệ. Bạn không thò tay vào trong két để lấy tiền trực tiếp. Két và logic kiểm tra được giấu kín bên trong.
Trong Python, quy ước tiền tố gạch dưới
_ (hoặc __ để đổi tên - name mangling) đánh dấu thuộc tính nội bộ; ta mở ra qua @property:class TaiKhoan:
def __init__(self, chu_tk, so_du=0):
self.chu_tk = chu_tk
self.__so_du = so_du # nội bộ, không cho sửa trực tiếp
@property
def so_du(self):
return self.__so_du
def nap(self, tien):
if tien <= 0:
raise ValueError("So tien nap phai duong")
self.__so_du += tien
def rut(self, tien):
if tien > self.__so_du:
raise ValueError("So du khong du")
self.__so_du -= tien
tk = TaiKhoan("Kai", 100)
tk.nap(50)
tk.rut(30)
print("So du:", tk.so_du)
# Muon "móc ruột" thẳng sẽ bị chặn:
try:
tk.__so_du = -999
print("Gia tri thuc te van la:", tk.so_du)
except Exception as e:
print("Loi:", e)
So du: 120
Gia tri thuc te van la: 120
Gán
tk.__so_du = -999 chỉ tạo ra một thuộc tính mới tên khác (do name mangling), chứ không đụng được số dư thật - nên tk.so_du vẫn là 120. Lưu ý: đóng gói trong Python là quy ước, không phải rào cứng như private của Java; nó nhắc "đừng chạm", chứ không cấm tuyệt đối.2. Tính kế thừa (Inheritance)
Kế thừa cho một lớp con (subclass) thừa hưởng thuộc tính và phương thức của lớp cha (superclass), rồi bổ sung hoặc ghi đè theo nhu cầu. Mục đích: tái sử dụng phần chung, tránh chép code.
Ví von: mẫu đơn có sẵn. Công ty in một mẫu chung (họ tên, ngày tháng); đơn xin nghỉ phép và đơn xin tăng lương đều "kế thừa" khung đó rồi thêm phần riêng, thay vì thiết kế lại từ giấy trắng.
class DongVat:
def __init__(self, ten):
self.ten = ten
def keu(self):
return "..."
def gioi_thieu(self):
return f"{self.ten} keu: {self.keu()}"
class Cho(DongVat):
def keu(self): # ghi đè phương thức của cha
return "Gau gau"
class Meo(DongVat):
def keu(self):
return "Meo meo"
for con in [Cho("Milu"), Meo("Tom")]:
print(con.gioi_thieu())
Milu keu: Gau gau
Tom keu: Meo meo
Cho và Meo không cần viết lại __init__ hay gioi_thieu - chúng dùng lại của DongVat, chỉ ghi đè đúng phần keu() khác nhau.3. Tính đa hình (Polymorphism)
Đa hình nghĩa là "nhiều hình dạng": cùng một lời gọi phương thức có thể cho hành vi khác nhau tuỳ đối tượng thật đứng sau. Ở ví dụ trên, vòng lặp gọi
con.gioi_thieu() mà không cần biết đó là chó hay mèo - mỗi object tự chọn keu() của mình. Đó chính là đa hình.Ví von: nút "Play" trên các thiết bị. Cùng một nút, nhưng trên máy nghe nhạc thì phát nhạc, trên đầu DVD thì phát phim. Bạn bấm cùng một hành động, kết quả tuỳ thiết bị.
Điểm mạnh: code xử lý có thể làm việc với bất kỳ loại nào miễn nó có phương thức phù hợp, nên thêm loại mới không phải sửa vòng lặp:
def dan_dong_ca(danh_sach):
for con in danh_sach:
print(con.keu())
class Vit(DongVat):
def keu(self):
return "Quac quac"
dan_dong_ca([Cho("Milu"), Meo("Tom"), Vit("Donald")])
Gau gau
Meo meo
Quac quac
Thêm
Vit mà dan_dong_ca không đổi một dòng. Python theo phong cách "duck typing": miễn object có keu() thì dùng được, không nhất thiết phải cùng lớp cha.4. Tính trừu tượng (Abstraction)
Trừu tượng là phơi ra cái cần thiết, giấu đi chi tiết cài đặt. Người dùng lớp chỉ thấy "làm được gì" chứ không phải "làm bằng cách nào". Trừu tượng và đóng gói hay đi cùng nhau, nhưng khác góc nhìn: đóng gói thiên về che dữ liệu, còn trừu tượng thiên về thiết kế một giao diện (interface) đơn giản.
Ví von: lái xe. Bạn chỉ cần vô-lăng, chân ga, chân phanh. Chuyện phun xăng, đánh lửa, hộp số hoạt động ra sao được giấu sau tấm capo. Giao diện lái xe đơn giản, còn bên trong thì phức tạp.
Python có module
abc để định nghĩa lớp trừu tượng (abstract base class) - buộc lớp con phải cài đặt các phương thức đã khai báo:from abc import ABC, abstractmethod
class HinhHoc(ABC):
@abstractmethod
def dien_tich(self):
...
class HinhTron(HinhHoc):
def __init__(self, r):
self.r = r
def dien_tich(self):
return 3.14159 * self.r ** 2
class HinhChuNhat(HinhHoc):
def __init__(self, dai, rong):
self.dai = dai
self.rong = rong
def dien_tich(self):
return self.dai * self.rong
for h in [HinhTron(2), HinhChuNhat(3, 4)]:
print(round(h.dien_tich(), 2))
12.57
12
Ai dùng
HinhHoc chỉ cần biết "gọi dien_tich() là ra diện tích", không cần quan tâm công thức của hình tròn hay hình chữ nhật. Nếu tạo một lớp con quên cài dien_tich(), Python sẽ báo lỗi ngay khi khởi tạo - đó là cách abstract class ép bạn giữ đúng hợp đồng.OOP quan trọng với Design Pattern ở chỗ nào?
Đây là phần tôi muốn bạn nhớ nhất, vì nó là lý do bài này mở đầu cho cả series Design Patterns. Bốn tính chất ở trên không phải kiến thức để đi thi. Chúng là vật liệu. Design pattern chỉ là cách người ta ghép mấy vật liệu đó lại theo một kỷ luật đã được kiểm chứng.
Mạch dẫn đi như sau:
- OOP cho bạn đơn vị để chia hệ thống: object gói dữ liệu + hành vi.
- Đóng gói dựng ranh giới. Cái gì hay thay đổi thì nhét vào sau ranh giới đó, bên ngoài không thấy, nên sửa bên trong không làm gãy bên ngoài.
- Đa hình cho phép nhiều cài đặt cùng đáp ứng một lời gọi. Đây là điểm bản lề: không có đa hình thì không thể hoán đổi cài đặt lúc chạy.
- Program to interface là kỷ luật viết code phụ thuộc vào cái hợp đồng (những phương thức nào phải có) chứ không phụ thuộc vào một class cụ thể.
- Composition là cách lắp: thay vì kế thừa để "có thêm" hành vi, bạn tiêm một object khác vào và gọi nó.
- Design pattern là những công thức lắp ráp đã có tên gọi, sinh ra từ đúng năm bước trên.
Nói cho gọn: đóng gói là thứ khiến "giấu cái hay thay đổi" thành khả thi, đa hình là thứ khiến "hoán đổi cài đặt" thành khả thi. Gần như mọi pattern kinh điển đều đứng trên hai chân đó. Strategy giấu thuật toán sau một interface rồi hoán đổi. Adapter giấu một API lạ sau interface mà hệ thống bạn đang quen. Decorator bọc một object vào object khác cùng interface để thêm hành vi. Không có gì huyền bí ở đây cả.
Một ví dụ nhỏ để bạn thấy năm bước kia nằm gọn trong mười mấy dòng:
class GiaoHang:
def phi(self, km):
raise NotImplementedError
class GiaoNhanh(GiaoHang):
def phi(self, km):
return 15000 + 5000 * km
class GiaoTietKiem(GiaoHang):
def phi(self, km):
return 10000 + 2000 * km
class DonHang:
def __init__(self, km, cach_giao: GiaoHang):
self.km = km
self._cach_giao = cach_giao # dong goi: ben ngoai khong doc truc tiep
def tong_phi(self):
return self._cach_giao.phi(self.km) # da hinh: goi mot ten, chay nhieu than
for cach in (GiaoNhanh(), GiaoTietKiem()):
don = DonHang(km=4, cach_giao=cach)
print(type(cach).__name__, "->", don.tong_phi())
GiaoNhanh -> 35000
GiaoTietKiem -> 18000
DonHang không biết gì về cách tính phí. Nó chỉ biết "có ai đó cho tôi một object có phi()". Thêm GiaoHoaToc ngày mai thì DonHang không đổi một dòng. Đoạn code này đã là Strategy pattern rồi, chỉ là chưa ai gắn tên cho nó. Pattern không phải phép màu, nó là cái tên chung cho một cách dùng có kỷ luật của chính bốn tính chất bạn vừa đọc.Đi tiếp: bước bản lề ở giữa mạch trên có hẳn một bài riêng - Program to interface, không phải implementation. Muốn xem đoạn code trên được đặt tên và mở rộng thế nào thì đọc Strategy Pattern. Toàn bộ lộ trình nằm ở hub Design Patterns.
Cạm bẫy thường gặp
Coi chừng:
- Lạm dụng kế thừa. Kế thừa sâu (con của con của con...) khiến hành vi khó lần ra. Nguyên tắc kinh điển: ưu tiên kết hợp (composition) hơn kế thừa (inheritance) - gắn đối tượng vào nhau thay vì chồng tầng lớp cha con.
- Tưởng đóng gói của Python là bất khả xâm phạm.
__chỉ đổi tên, không khoá cứng; vẫn truy cập được nếu cố tình. Đừng dựa vào nó để bảo mật. - Getter/setter cho mọi thứ. Bọc mọi thuộc tính bằng
get_x()/set_x()chẳng thêm giá trị gì - thế thì khác gì để public. Chỉ đóng gói khi thật sự có ràng buộc (validate, tính toán, giữ bất biến). - Nhồi OOP vào bài toán nhỏ. Một script 30 dòng không cần năm class. Dùng đúng liều.
OOP trong code backend thật
Lý thuyết xong rồi, giờ nói chỗ bạn thật sự gặp OOP khi đi làm backend. Không phải ở chó mèo, mà ở năm chỗ này:
- Model / entity trong ORM.
class User(models.Model)của Django hay một mapped class của SQLAlchemy chính là OOP: thuộc tính ánh xạ cột, phương thức chứa hành vi miền nghiệp vụ (user.deactivate()), và kế thừa từ base class của framework. - Service / repository class.
OrderServicegom các thao tác nghiệp vụ,OrderRepositorygom truy vấn dữ liệu. Tách ra thành class để tiêm được bản giả (fake) khi viết test, thay vì gọi thẳng database trong controller. - Cây exception.
AppError->NotFoundError,ValidationError,PaymentError. Đây là chỗ kế thừa thật sự có lý: tầng trên bắtAppErrorlà bắt được cả họ, còn chỗ cần chi tiết thì bắt lớp con. - Middleware / handler class. Mỗi middleware là một object có một giao diện cố định (nhận request, gọi tiếp, trả response). Framework xếp chúng thành chuỗi mà không cần biết bên trong từng cái làm gì.
- Client wrapper cho API bên ngoài.
PaymentGatewayvới hai cài đặtStripeGatewayvàSandboxGateway. Đây là chỗ đa hình cứu bạn: môi trường test cắm bản sandbox, production cắm bản thật, code nghiệp vụ không đổi.
Nhưng phải nói thẳng một câu: nhiều phần của backend hiện đại vẫn là hàm thuần, và như thế là đúng. Một hàm chuyển đổi dữ liệu, một validator, một job tính toán, một endpoint mỏng chỉ nhận vào rồi trả ra - bọc chúng vào class thường chỉ thêm tầng chứ không thêm giá trị. OOP không phải mặc định cho mọi thứ. Bạn dùng class khi có trạng thái cần giữ bất biến, hoặc có nhiều cài đặt cần hoán đổi. Không có hai thứ đó thì một hàm là đủ.
Trade-off
Không có gì miễn phí. Đây là bảng cân đối trung thực của OOP:
Được:
- Kiểm soát độ phức tạp: hệ thống lớn được chia thành các mảnh có ranh giới, đọc từng mảnh vẫn hiểu được.
- Đóng gói bất biến (invariant): số dư không bao giờ âm, trạng thái đơn hàng không nhảy bậy - vì chỉ có một chỗ được phép sửa.
- Ngôn ngữ chung khi làm nhóm: nói "cái
OrderRepository" là cả team hiểu đang nói về phần nào, khỏi mô tả dài dòng. - Dễ thay thế cài đặt nhờ đa hình: đổi nhà cung cấp thanh toán, cắm bản giả khi test, thêm loại mới mà không sửa code gọi.
Phải trả giá:
- Dễ trừu tượng hoá quá tay: dựng interface cho thứ chỉ có duy nhất một cài đặt, rồi phải mở bốn file mới hiểu một luồng đơn giản.
- Kế thừa sâu sinh ra fragile base class: sửa một dòng ở lớp cha làm gãy những lớp con mà bạn còn chẳng nhớ là chúng tồn tại.
- Nhiều boilerplate: constructor, property, hằng hà class nhỏ - code dài ra mà logic không tăng thêm.
- Nhiều bài toán hợp phong cách hàm hơn: xử lý dữ liệu, pipeline biến đổi, tính toán thuần - ở đó hàm không trạng thái dễ test và dễ ghép hơn class.
- Khó lần vết khi state nằm rải trong nhiều object: giá trị sai hiện ra ở đây nhưng bị gán từ đâu thì phải dò ngược qua mấy lớp mới ra.
Nguyên tắc của tôi: bắt đầu bằng hàm, chỉ nâng lên class khi bạn thấy dữ liệu và hành vi cứ dính chùm đi với nhau, hoặc khi bạn cần hoán đổi cài đặt. Đi theo chiều đó ít tốn kém hơn nhiều so với gỡ một cây kế thừa năm tầng dựng sẵn từ ngày đầu. Muốn đi sâu về các nguyên tắc giữ cho thiết kế không phình ra, đọc thêm SOLID trong lập trình.
Tóm tắt
- OOP tổ chức code quanh đối tượng = dữ liệu + hành vi, định nghĩa bằng class và tạo ra instance.
- Đóng gói: gom dữ liệu + phương thức, che trạng thái nội bộ, chỉ cho vào qua cửa kiểm soát.
- Kế thừa: lớp con dùng lại và ghi đè lớp cha để tránh chép code.
- Đa hình: cùng lời gọi, hành vi khác nhau tuỳ đối tượng - thêm loại mới không phải sửa code cũ.
- Trừu tượng: phơi giao diện đơn giản, giấu chi tiết cài đặt.
- OOP là công cụ để trị độ phức tạp, không phải mục tiêu. Ưu tiên composition, tránh kế thừa sâu, và dùng đúng liều.
Nguồn tham khảo
- Python Docs - Classes (tài liệu chính thức về class, thuộc tính, kế thừa).
- Python Docs -
abc(Abstract Base Classes). - Python Docs -
property. - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley, 1994) - nguồn của nguyên tắc gốc "Favor object composition over class inheritance".
- Kai