מה זה כימוס (Encapsulation)?

נניח שאפליקציית בנק שומרת את היתרה של כל חשבון במשתנה רגיל. כל שורה בכל מקום בתוכנית יכולה לכתוב account.balance = -500, ושום דבר לא עוצר אותה. כשיתרה שלילית מופיעה בפרודקשן, צריך לחפש בכל בסיס הקוד כל מקום שנגע בה. כימוס פותר את זה: היתרה יכולה להשתנות רק דרך כמה מתודות, והמתודות האלה אוכפות את הכללים, למשל שמשיכה לעולם לא תעלה על היתרה.

איך כימוס עובד

כימוס משלב שני רעיונות:

1. איגוד. הנתונים (היתרה) והקוד שעובד עליהם (הפקדה, משיכה) נמצאים באותה מחלקה.
2. הסתרה. קוד אחר רואה רק את הממשק הציבורי של המחלקה. הנתונים שמאחוריו פנימיים, ולכן הם יכולים להשתנות רק בדרכים שהמחלקה מתירה.

הכלל שהמחלקה מגינה עליו נקרא אינווריאנט (invariant): כאן, "היתרה אף פעם לא שלילית". מכיוון שכל שינוי עובר דרך המתודות של המחלקה, האינווריאנט מתקיים לא משנה מה שאר התוכנית עושה.

class BankAccount:
    def __init__(self):
        self._balance = 0  # internal: change it only through the methods

    @property
    def balance(self):     # read-only from outside
        return self._balance

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount > self._balance:
            raise ValueError("not enough money")
        self._balance -= amount

acct = BankAccount()
acct.deposit(100)
acct.withdraw(30)
print(acct.balance)
try:
    acct.withdraw(500)
except ValueError as err:
    print("refused:", err)

70
refused: not enough money

קוד חיצוני יכול לקרוא את acct.balance, אבל ל-property אין setter, ולכן acct.balance = 1000 זורק AttributeError. אם היתרה אי פעם שגויה, יש בדיוק שתי מתודות לבדוק.

כימוס ב-Python

ב-Python אין מילת מפתח private. היא נשענת על מוסכמות שמות שכל מתכנת Python מכיר:

• name: ציבורי, חלק מהממשק.
• _name: פנימי. שום דבר לא מונע מכם לקרוא אותו, אבל הקו התחתון בהתחלה אומר "אל תסתמכו על זה".
• __name: Python משנה את השם שלו בתוך המחלקה (name mangling), כך שתת מחלקה לא יכולה לדרוס אותו בטעות.
• @property: הופך מתודה למשהו שנקרא כמו מאפיין, כך שאפשר להוסיף בדיקות מאוחר יותר בלי לשנות שום קוד שקורא לו.

class Counter:
    def __init__(self):
        self._count = 0      # one underscore: "internal, please don't touch"
        self.__secret = 42   # two underscores: the name gets mangled

c = Counter()
print(c._count)                   # still readable: it is only a convention
print(hasattr(c, "__secret"))     # the plain name does not exist
print(c._Counter__secret)         # Python renamed it to _Counter__secret

0
False
42

שינוי השם מונע תקלות, לא גישה: השם המשונה עדיין עובד. Python סומכת על המתכנתים שיכבדו את הקו התחתון. בפועל רוב הקוד ב-Python משתמש בקו תחתון אחד יחד עם @property, ושומר קו תחתון כפול למחלקות שנועדו לשמש כמחלקות בסיס. עוד על כתיבת מחלקות תמצאו בתיעוד על מחלקות ב-Python.

כימוס ב-Java, C++ ו-JavaScript

שפות אחרות אוכפות את ההסתרה. ב-Java, אפשר להשתמש בשדה private רק בתוך המחלקה שלו:

public class BankAccount {
    private int balance;  // hidden from every other class

    public int getBalance() { return balance; }

    public void withdraw(int amount) {
        if (amount > balance) throw new IllegalArgumentException("not enough money");
        balance -= amount;
    }
}

כתיבת account.balance = 1000; במחלקה אחרת לא עוברת קומפילציה: javac מדווח balance has private access in BankAccount.

ב-C++ חברי class פרטיים כברירת מחדל וחברי struct ציבוריים. את השדות הפרטיים עם # של JavaScript, שנוספו ב-ES2022, אי אפשר לקרוא מחוץ למחלקה בכלל. התיעוד מכסה כל אחד מהם: מגדירי גישה ב-Java, מגדירי גישה ב-C++ ושדות פרטיים ב-JavaScript.

למה כימוס חשוב

• הכללים נמצאים במקום אחד. הבדיקה "אין משיכה מעל היתרה" נכתבת פעם אחת, בתוך withdraw, במקום לפני כל משיכה בתוכנית.
• אפשר לשנות את הפנים בחופשיות. אם מחליטים לשמור כסף כאגורות שלמות במקום כ-float, רק המחלקה משתנה. קוד שקורא ל-deposit(100) ממשיך לעבוד.
• דיבאגינג קל יותר. כשערך שגוי, החשודות הן כמה המתודות שמורשות לשנות אותו, לא כל שורה בתוכנית.
• פחות מה ללמוד ולבדוק. מחלקה עם שלוש מתודות ציבוריות אפשר להבין ולבדוק דרך שלוש המתודות האלה.

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

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

טעויות נפוצות

• getter ו-setter לכל שדה. setBalance שמקבל כל מספר לא מגן על כלום. הציעו את הפעולות שהאובייקט צריך (withdraw), לא גישה ישירה לכל שדה.
• החזרת אובייקטים פנימיים. מתודה שמחזירה self._items מוסרת לקורא את הרשימה האמיתית, שעכשיו הוא יכול לשנות. החזירו עותק או tuple במקום.
• התייחסות ל-private כאל אבטחה. מגדירי גישה מונעים טעויות, לא מתקפות. קוד Java יכול לקרוא שדות פרטיים דרך reflection, וקוד Python יכול לקרוא _name ישירות. סיסמאות ומפתחות צריכים הגנה אמיתית, כמו גיבוב והצפנה.

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

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