מה זה אבסטרקציה (Abstraction) בתכנות?

כשכותבים print("hi"), לא חושבים על הדרך שבה האותיות מגיעות למסך. מתחת לשורה האחת הזו, Python הופכת את הטקסט לבייטים ומבקשת ממערכת ההפעלה לכתוב אותם, מערכת ההפעלה מעבירה אותם לטרמינל, והטרמינל מצייר כל אות בפיקסלים בעזרת גופן. כל שכבה נותנת לשכבה שמעליה הבטחה פשוטה ומסתירה איך היא מקיימת אותה. ההסתרה הזו היא אבסטרקציה, וכל תוכנית יושבת על הרבה שכבות כאלה.

רמות של אבסטרקציה

כל רמה בנויה מזו שמתחתיה, ואפשר להבין אותה בלעדיה. אפשר לכתוב Python שעובד בלי לדעת מה זה בלוק בדיסק, ומערכת ההפעלה יכולה לשמור קובץ בלי לדעת שיש בו קוד Python.

איך אבסטרקציה עובדת בקוד

מתכנתים בונים שכבות משלהם בשתי דרכים עיקריות.

אבסטרקציה פרוצדורלית היא פונקציה. השם, הפרמטרים וערך ההחזרה שלה הם הממשק; הגוף הוא הפרט המוסתר. ברגע ש-average(scores) קיימת, שאר התוכנית משתמשת בה בלי לקרוא איך היא מחברת ומחלקת.

אבסטרקציית נתונים מגדירה טיפוס לפי מה שאפשר לעשות איתו, לא לפי איך הוא שומר דברים. תור הוא "מוסיפים מאחור, מוציאים מקדימה". איך הפריטים יושבים בזיכרון זו החלטה פרטית:

from collections import deque

class Queue:
    """First in, first out. Callers only see add() and next()."""
    def __init__(self):
        self._items = deque()     # swap this for a list and callers never notice
    def add(self, item):
        self._items.append(item)
    def next(self):
        return self._items.popleft()
    def __len__(self):
        return len(self._items)

orders = Queue()
for dish in ["soup", "pasta", "cake"]:
    orders.add(dish)
while len(orders):
    print("serving", orders.next())

serving soup
serving pasta
serving cake

הקוד שלמטה לא יודע כלום על deque. אם מחליפים אותו ברשימה רגילה וב-pop(0), הפלט זהה, רק איטי יותר בתורים ארוכים, כי הסרת הפריט הראשון מרשימה מזיזה את כל שאר הפריטים. הממשק נשאר אותו דבר, ולכן שום דבר מחוץ למחלקה לא היה צריך להשתנות.

מחלקות אבסטרקטיות וממשקים

בתכנות מונחה עצמים, אבסטרקציה בדרך כלל פירושה לקבוע מה משפחה של מחלקות חייבת לעשות, ולהשאיר את האיך לכל מחלקה. ב-Python, המודול abc מסמן מתודה כאבסטרקטית; אי אפשר ליצור מופע של מחלקה שיש בה מתודה אבסטרקטית שלא מומשה:

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, to, text):
        """Every notifier must say how it sends a message."""

class Email(Notifier):
    def send(self, to, text):
        print(f"email to {to}: {text}")

class SMS(Notifier):
    def send(self, to, text):
        print(f"sms to {to}: {text}")

def remind(notifier, user):
    notifier.send(user, "Your package arrives today")

remind(Email(), "ana@example.com")
remind(SMS(), "+15550100")
try:
    Notifier()
except TypeError:
    print("Notifier is abstract: create an Email or an SMS instead")

email to ana@example.com: Your package arrives today
sms to +15550100: Your package arrives today
Notifier is abstract: create an Email or an SMS instead

remind() תלויה רק באבסטרקציה: כל דבר שיש לו מתודה send. כדי להוסיף התראות פוש כותבים מחלקה חדשה אחת, ו-remind() לא משתנה. הצעד האחרון הזה, קריאה אחת שמריצה קוד שונה למחלקות שונות, הוא פולימורפיזם: האבסטרקציה מגדירה את הממשק המשותף, והפולימורפיזם גורם לו לעבוד.

ב-Java יש את אותם כלים כמילות מפתח:

interface Notifier {
    void send(String to, String text);
}

class Email implements Notifier {
    public void send(String to, String text) { /* talk to the mail server */ }
}

כתיבת new Notifier() היא שגיאת קומפילציה, כי לממשק אין מימוש להריץ. התיעוד מסביר בפירוט על מחלקות אבסטרקטיות ועל ממשקים ב-Java.

אבסטרקציה מול כימוס (Encapsulation)

שני הרעיונות מופיעים יחד כל כך הרבה, שקל לבלבל ביניהם.

האבסטרקציה מחליטה אילו פעולות להציג; הכימוס מוודא שכל השאר נשאר מוסתר. ה-Queue שלמעלה עושה את שניהם: add ו-next הם האבסטרקציה, והקו התחתון ב-_items הוא הכימוס.

אבסטרקציות דולפות וטעויות נוספות

ג'ואל ספולסקי (Joel Spolsky) ניסח ב-2002 את חוק האבסטרקציות הדולפות (leaky abstractions): כל אבסטרקציה שאינה טריוויאלית מעבירה חלק מהפרטים המוסתרים. מספרי נקודה צפה הם הדליפה הקלאסית. הם נראים כמו מספרים עשרוניים רגילים, עד שהאחסון הבינארי שמתחת מציץ החוצה:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

אי אפשר לשמור בדיוק לא את 0.1 ולא את 0.2 בביטים בינאריים, ולכן הסכום יוצא קצת לא מדויק. אפשר להשתמש ב-floats במשך שנים בלי לחשוב על זה, אבל לא לנצח, ולכן כדאי להכיר שכבה אחת מתחת לזו שבה אתם עובדים.

עוד שתי טעויות נפוצות:

• אבסטרקציה מוקדמת מדי. היררכיית מחלקות שנבנתה למקרים שלא מגיעים היא קוד מיותר שצריך לקרוא ולשנות. סנדי מץ (Sandi Metz) ניסחה את זה כך: "שכפול זול בהרבה מאבסטרקציה שגויה".
• בלבול בין אבסטרקציה למילת המפתח abstract. מחלקות אבסטרקטיות הן כלי אחד. כל פונקציה עם שם טוב היא גם אבסטרקציה.

לאן ממשיכים מכאן

קראו על כימוס ועל פולימורפיזם כדי להשלים את התמונה של תכנות מונחה עצמים. העמוד על מערכת ההפעלה מציג את האבסטרקציה הגדולה ביותר שהתוכניות שלכם נשענות עליה. לתרגול, קורס Python בונה מחלקות ופונקציות מההתחלה, וקורס Java מכסה מחלקות אבסטרקטיות וממשקים.