หลักการสำคัญทั้งสี่ของ OOP มีอะไรบ้าง?

Question

Accepted Answer

การเขียนโปรแกรมเชิงวัตถุ (object-oriented programming) ตั้งอยู่บนหลักการหลักสี่ข้อ ได้แก่ **Encapsulation, Inheritance, Polymorphism และ Abstraction** Java ถูกสร้างขึ้นรอบ ๆ หลักการเหล่านี้ และการเข้าใจหลักการเหล่านี้ถือเป็นพื้นฐานสำคัญในการออกแบบโปรแกรม Java

## 1. Encapsulation — รวมข้อมูลไว้ด้วยกัน + ซ่อนรายละเอียดภายใน

```java
public class Account {
    private double balance;          // hidden — can't be accessed directly outside

public void deposit(double amount) {   // controlled access via methods
        if (amount > 0) balance += amount;  // can enforce rules
    }
    public double getBalance() { return balance; }
}
```

Encapsulation ซ่อนสถานะภายใน (`private`) และเปิดให้เข้าถึงได้แบบควบคุม (เมธอด/getter/setter ที่เป็น public) สิ่งนี้ช่วยปกป้อง invariant ต่าง ๆ คุณไม่สามารถตั้งยอดคงเหลือให้ติดลบได้โดยตรง และทำให้คุณเปลี่ยนรายละเอียดภายในได้โดยไม่กระทบกับผู้เรียกใช้

## 2. Inheritance — นำกลับมาใช้ซ้ำผ่านความสัมพันธ์แบบ "is-a"

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

Inheritance ทำให้คลาสลูก (subclass) สามารถนำพฤติกรรมของคลาสแม่ (superclass) กลับมาใช้ซ้ำและขยายต่อได้ เป็นการจำลองความสัมพันธ์แบบ "is-a" และหลีกเลี่ยงการเขียนโค้ดซ้ำซ้อน

## 3. Polymorphism — อินเทอร์เฟซเดียว หลายรูปแบบ

```java
Animal a = new Dog();     // a Dog treated as an Animal
a.makeSound();            // calls Dog's overridden version at RUNTIME (dynamic dispatch)

// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
```

Polymorphism ทำให้คุณจัดการกับ subclass ที่ต่างกันได้อย่างเป็นเอกภาพผ่านชนิดร่วมหนึ่งเดียว โดยเมธอดที่ถูก override ของอ็อบเจกต์ **จริง** จะถูกเรียกในขณะรันไทม์ ทำให้ได้โค้ดที่ยืดหยุ่นและขยายต่อได้

## 4. Abstraction — เปิดเผยว่า "ทำอะไร" ซ่อนว่า "ทำอย่างไร"

```java
interface PaymentProcessor {
    void pay(double amount);   // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
    public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
```

Abstraction (ผ่าน interface/abstract class) เปิดเผยสัญญา (contract) แบบที่เรียบง่ายลงในขณะที่ซ่อนการ implement ที่ซับซ้อนไว้ ทำให้คุณสามารถสลับการ implement ได้และลดการพึ่งพากันระหว่างส่วนต่าง ๆ (coupling)

## ทำไมจึงสำคัญ

หลักการสำคัญทั้งสี่ข้อนี้คือรากฐานของการออกแบบเชิงวัตถุและของตัว Java เอง

Encapsulation ปกป้องความถูกต้องของข้อมูลและรองรับการเปลี่ยนแปลงอย่างปลอดภัย Inheritance ส่งเสริมการนำกลับมาใช้ซ้ำ Polymorphism ให้ความยืดหยุ่นและความสามารถในการขยายต่อ (จัดการหลายชนิดอย่างเป็นเอกภาพ พฤติกรรมถูกตัดสินในขณะรันไทม์) ส่วน Abstraction ช่วยลด coupling และความซับซ้อน

การเข้าใจหลักการเหล่านี้ไม่ใช่แค่เรื่องของศัพท์เฉพาะ แต่มันชี้นำวิธีที่คุณจัดโครงสร้างคลาส ออกแบบ API และสร้างระบบที่ดูแลรักษาและขยายต่อได้

หลักการเหล่านี้ยังเป็นหัวข้อสัมภาษณ์ที่พบบ่อยที่สุดด้วย เพราะมันสะท้อนว่านักพัฒนาคิดในกรอบ OOP ที่ถูกต้องหรือไม่ ซึ่งจำเป็นต่อการทำงานอย่างมีประสิทธิภาพในระบบนิเวศของ Java ที่ยึดคลาสเป็นศูนย์กลาง