การแยกส่วน (Abstraction) ใน OOP คืออะไร?

Question

IT Interview Practice · Accepted Answer

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

## สิ่งที่ทำ เทียบกับ วิธีการ

```python
from abc import ABC, abstractmethod

class PaymentGateway(ABC):          # the abstraction: "what"
    @abstractmethod
    def charge(self, amount): ...    # callers only need this contract

class StripeGateway(PaymentGateway): # one "how"
    def charge(self, amount):
        # talk to Stripe's API, handle tokens, retries...
        return f"charged {amount} via Stripe"

class PayPalGateway(PaymentGateway): # another "how"
    def charge(self, amount):
        return f"charged {amount} via PayPal"

def checkout(gateway: PaymentGateway, amount):
    return gateway.charge(amount)    # depends only on the abstraction
```

`checkout` ไม่เคยรู้ว่ามันเป็น Stripe หรือ PayPal — มันขึ้นอยู่กับ *แนวคิด* ของการเรียกเก็บเงิน ไม่ใช่รายละเอียด

## การแยกส่วน เทียบกับ การห่อหุ้ม

พวกมันสัมพันธ์กันแต่แตกต่างกัน: **การห่อหุ้ม** ซ่อนสถานะเพื่อปกป้องมัน; **การแยกส่วน** ซ่อนความซับซ้อนเพื่อทำให้อินเทอร์เฟสนั้นง่ายขึ้น การห่อหุ้มเกี่ยวกับ *การปกป้อง*; การแยกส่วนเกี่ยวกับ *สิ่งที่ควรแสดง*

## สิ่งที่ต้องระวัง
การแยกส่วนที่รั่ว (ที่รายละเอียดการใช้งานรั่วไหล) และการแยกส่วนเร็วเกินไป (สร้างขึ้นก่อนที่คุณจะเข้าใจปัญหา) ทั้งสองอย่างนี้ เป็นอันตราย สิ่งที่ต้องแยกส่วนคือสิ่งที่เปลี่ยนแปลงอย่างแท้จริง

## ทำไมมันถึงสำคัญ

การแยกส่วน คือวิธีที่คุณ บริหารความซับซ้อน: ผู้เรียกใช้ฟังก์ชันคิดเกี่ยวกับอินเทอร์เฟสขนาดเล็ก แทนที่จะเป็นระบบย่อยทั้งหมด

มันทำให้สามารถสลับการใช้งาน — การเพิ่มผู้ให้บริการการชำระเงินใหม่ จะส่งผลต่อคลาสหนึ่งเท่านั้น ไม่ใช่ผู้เรียกใช้แต่ละคน — ซึ่งเป็นรากฐานของการออกแบบที่ยืดหยุ่น สามารถทดสอบได้

สิ่งที่ทำ เทียบกับ วิธีการ

การแยกส่วน เทียบกับ การห่อหุ้ม

สิ่งที่ต้องระวัง

ทำไมมันถึงสำคัญ

คำถามที่เกี่ยวข้อง