Bốn trụ cột của OOP là gì?

Question

Accepted Answer

Lập trình hướng đối tượng dựa trên bốn nguyên lý cốt lõi — **Encapsulation, Inheritance, Polymorphism, và Abstraction**. Java được xây dựng xoay quanh chúng, và hiểu chúng là nền tảng để thiết kế chương trình Java.

## 1. Encapsulation — đóng gói dữ liệu + che giấu nội bộ

```java
public class Account {
    private double balance;          // ẩn — không thể truy cập trực tiếp từ bên ngoài

public void deposit(double amount) {   // truy cập có kiểm soát qua phương thức
        if (amount > 0) balance += amount;  // có thể áp dụng quy tắc
    }
    public double getBalance() { return balance; }
}
```

Encapsulation che giấu trạng thái nội bộ (`private`) và mở ra truy cập có kiểm soát (phương thức public/getter/setter). Điều này bảo vệ các bất biến (invariant) — bạn không thể đặt balance âm trực tiếp — và cho phép thay đổi nội bộ mà không phá vỡ caller.

## 2. Inheritance — tái sử dụng qua quan hệ "is-a"

```java
class Animal {
    void eat() { System.out.println("eating"); }
}
class Dog extends Animal {   // Dog IS-A Animal — kế thừa eat()
    void bark() { System.out.println("woof"); }
}
```

Inheritance cho phép một subclass tái sử dụng và mở rộng hành vi của superclass, mô hình hóa quan hệ "is-a" và tránh lặp code.

## 3. Polymorphism — một interface, nhiều dạng

```java
Animal a = new Dog();     // một Dog được xử lý như một Animal
a.makeSound();            // gọi bản override của Dog tại RUNTIME (dynamic dispatch)

// cùng một phương thức hành xử khác nhau tùy theo object thực tế:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // mỗi con phát ra âm thanh riêng
```

Polymorphism cho phép bạn xử lý các subclass khác nhau một cách đồng nhất thông qua một kiểu chung, với phương thức được override của object **thực tế** được gọi tại runtime — tạo ra code linh hoạt, dễ mở rộng.

## 4. Abstraction — lộ ra cái gì, che giấu cách làm

```java
interface PaymentProcessor {
    void pay(double amount);   // LÀM GÌ, không phải LÀM THẾ NÀO
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* phần triển khai phức tạp được che giấu */ }
}
// caller phụ thuộc vào abstraction, không phải implementation cụ thể
PaymentProcessor processor = new StripeProcessor();
```

Abstraction (qua interface/abstract class) lộ ra một hợp đồng đơn giản hóa trong khi che giấu phần triển khai phức tạp — cho phép thay đổi implementation và giảm coupling.

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

Bốn trụ cột là nền tảng của thiết kế hướng đối tượng và của chính Java.

Encapsulation bảo vệ tính toàn vẹn dữ liệu và cho phép thay đổi an toàn; inheritance thúc đẩy tái sử dụng; polymorphism mang lại sự linh hoạt và khả năng mở rộng (xử lý nhiều kiểu đồng nhất, hành vi được phân giải tại runtime); abstraction giảm coupling và độ phức tạp.

Hiểu chúng không chỉ là thuật ngữ — chúng định hướng cách bạn cấu trúc class, thiết kế API, và xây dựng hệ thống dễ bảo trì, dễ mở rộng.

Chúng cũng nằm trong số những chủ đề phỏng vấn phổ biến nhất vì chúng cho thấy một developer có tư duy đúng theo OOP hay không, điều thiết yếu để làm việc hiệu quả trong hệ sinh thái lấy class làm trung tâm của Java.