דלגו לתוכן הראשי
גאמא קוד

High Level Programming

Singleton, Constructor, Protected, Interface, Polymorphism, Virtual Function, IComparable

תכנות מונחה עצמים ב-Java וב-C#: בנאים, Singleton, פולימורפיזם, ממשקים ו-IComparable.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

Singleton, Constructor, Protected, Interface, Polymorphism, Virtual Function, IComparable: המדריך המלא

בפרק הזה נעבור על שבעה נושאים מרכזיים בתכנות מונחה עצמים, עם דוגמאות ב-Java וב-C#:

  • Singleton: איך מגבילים מחלקה לאובייקט אחד, איך נותנים לכל התוכנית דרך להגיע אליו, ומה משתנה כשכמה threads מבקשים אותו בבת אחת.
  • Constructor: הרגע שבו הבנאי מופעל, מה המהדר מוסיף כשלא כתבתם בנאי, ואיך בנאים מעבירים את העבודה זה לזה ולמחלקת האב.
  • protected: הרשאת גישה שמשמעותה ב-Java שונה מזו שב-C#.
  • Interface, Polymorphism ו-Virtual function: שלושה רעיונות שנשענים זה על זה וקובעים איזו מתודה תרוץ בפועל.
  • IComparable: הממשק שמגדיר ב-C# סדר טבעי בין אובייקטים, והמקבילה שלו ב-Java.

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

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

נקודת המוצא: אתם מכירים מחלקה, אובייקט, שדה ומתודה, יודעים מה עושה static, ומכירים ירושה פשוטה (extends ב-Java, נקודתיים ב-C#). כששאלה לא אומרת באיזו שפה הקוד כתוב, הניחו שזו Java.

Singleton: מחלקה שיש לה אובייקט אחד בלבד

מה Singleton מבטיח ומאילו חלקים הוא בנוי

Singleton הוא דפוס עיצוב (Design Pattern) שנותן שתי הבטחות: למחלקה יהיה אובייקט אחד בלבד במשך כל זמן הריצה, ולכל חלקי התוכנית תהיה דרך אחת, גלובלית, להגיע אליו.

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

המימוש הקלאסי נשען על שלושה רכיבים, וכל אחד מהם פותר בעיה אחרת:

רכיבאיך הוא כתובמה הוא פותר
בנאי פרטיprivate על הבנאיקוד מחוץ למחלקה לא יכול לכתוב new ולייצר עותק משלו
שדה סטטי פרטישדה private static שמחזיק את האובייקטשדה static שייך למחלקה ולא לאובייקט מסוים, ולכן יש ממנו עותק אחד, ובו האובייקט נשמר בין קריאה לקריאה
נקודת גישה ציבוריתמתודה public static. ב-Java השם המקובל הוא getInstance(), וב-C# נהוג מאפיין סטטי בשם Instanceכל מי שצריך את האובייקט מבקש אותו דרכה ומקבל תמיד את אותו אחד
Java
final class AuditLog {
    private static final AuditLog THE_LOG = new AuditLog();  // created once, held by the class

    private AuditLog() {                                      // outside code cannot write new AuditLog()
        System.out.println("AuditLog opened");
    }

    public static AuditLog getInstance() {                    // the one way in
        return THE_LOG;
    }

    public void write(String line) { System.out.println("[audit] " + line); }
}

public class Main {
    public static void main(String[] args) {
        AuditLog first = AuditLog.getInstance();
        AuditLog second = AuditLog.getInstance();
        first.write("user 17 signed in");
        System.out.println(first == second);   // same object?
    }
}
פלט
AuditLog opened
[audit] user 17 signed in
true

שתי הקריאות ל-getInstance() מחזירות הפניה לאותו אובייקט, ולכן ההשוואה == נותנת true. ההודעה של הבנאי מופיעה פעם אחת בלבד.

הבנאי הפרטי הוא החומה מול קוד חיצוני. מחלקה אחרת שמנסה לבנות עותק נעצרת כבר בקומפילציה:

Java
final class Vault {
    private Vault() { }
}

class Client {
    void open() {
        Vault v = new Vault();   // outside code tries to create its own copy
    }
}
פלט
Client.java:7: error: Vault() has private access in Vault
        Vault v = new Vault();   // outside code tries to create its own copy
                  ^
1 error

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

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

למה רוב המימושים מוסיפים גם final למחלקה (ב-C#: sealed)? המילה הזו אוסרת לרשת מהמחלקה.

למעשה, מחלקה שכל הבנאים שלה פרטיים כמעט אינה ניתנת לירושה גם בלי final, כי כל בנאי של מחלקה יורשת חייב להפעיל בנאי של האב, והבנאי הפרטי סגור בפניו. החריג היחיד הוא מחלקה מקוננת בתוך ה-Singleton, שרואה את החברים הפרטיים שלו.

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

Java
final class Vault {
    private Vault() { }
}

class SecondVault extends Vault { }   // try to get a "second" Vault through a subclass
פלט
SecondVault.java:5: error: cannot inherit from final Vault
class SecondVault extends Vault { }   // try to get a "second" Vault through a subclass
                          ^
SecondVault.java:5: error: Vault() has private access in Vault
class SecondVault extends Vault { }   // try to get a "second" Vault through a subclass
^
2 errors

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

C#
IMetrics m = Hub.Instance;
INotifier n = Hub.Instance;
m.Count("orders");
n.Notify("stock low");
Console.WriteLine(ReferenceEquals(m, n));   // two interfaces, one object

interface IMetrics  { void Count(string key); }
interface INotifier { void Notify(string text); }

sealed class Hub : IMetrics, INotifier {
    private static readonly Lazy<Hub> holder = new Lazy<Hub>(() => new Hub());
    public static Hub Instance => holder.Value;   // C# style: a static property

    private Hub() { Console.WriteLine("Hub built"); }

    public void Count(string key)    { Console.WriteLine("count " + key); }
    public void Notify(string text)  { Console.WriteLine("notify " + text); }
}
פלט
Hub built
count orders
notify stock low
True

כאן עובר ההבדל בין Singleton לבין static class של C#. מחלקה סטטית אי אפשר ליצור, אי אפשר להעביר כארגומנט למתודה, ואסור לה לממש ממשק:

C#
interface IMetrics { void Count(string key); }

static class MetricsTools : IMetrics {      // a static class tries to play the same role
    public static void Count(string key) { }
}
פלט
Program.cs(3,29): error CS0714: 'MetricsTools': static classes cannot implement interfaces
Program.cs(3,29): error CS0736: 'MetricsTools' does not implement instance interface member 'IMetrics.Count(string)'. 'MetricsTools.Count(string)' cannot implement the interface member because it is static.

ההבטחה של 'אובייקט אחד' תקפה בתוך גבול מסוים. ב-Java הגבול הוא ה-class loader: אם שני class loaders שונים טוענים את אותה מחלקה, כל אחד מחזיק עותק נפרד שלה, ולכל עותק אובייקט משלו. ב-.NET הגבול הוא התהליך, וב-.NET Framework הישן הוא ה-AppDomain.

תרחיש 1: שלוש בעיות, ומי פותר כל אחת

צוות כותב מחלקה SessionManager כ-Singleton, ובודק מה יקרה אם יוותר על כל אחד מהרכיבים.

  • בלי בנאי פרטי: כל מחלקה יכולה לכתוב new SessionManager(), ומספר האובייקטים כבר לא בשליטת המחלקה.
  • אם האובייקט נשמר בשדה מופע רגיל במקום בשדה static: כל אובייקט מחזיק שדה משלו, ואין מקום אחד משותף שכולם פונים אליו.
  • אם getInstance() כותבת return new SessionManager();: כל קריאה בונה אובייקט חדש, וזה ההפך הגמור מהדפוס.
  • גם כששלושת הרכיבים במקומם, גרסה עצלה של getInstance() עדיין פגיעה כששני threads קוראים לה באותו רגע. את זה הבנאי הפרטי לא פותר, וצריך סנכרון.
טעויות נפוצות
  • Singleton קיים כדי שכל המופעים של המחלקה יוכלו לשמש כמה threads בבטחה. אין 'כל המופעים': יש אחד. הדפוס מבטיח מופע יחיד ודרך גישה אחת, ובטיחות בריבוי threads אינה חלק מההבטחה שלו.
  • תפקיד ה-Singleton לקבוע חוזה משותף שכל תת-המחלקות יממשו. חוזה משותף הוא העבודה של ממשק או של מחלקת בסיס. Singleton עוסק בכמות המופעים ובדרך להגיע אליהם.
  • מסמנים את השדה הסטטי volatile, וכך קוד חיצוני כבר לא יכול לכתוב new. volatile עוסק בנראות של ערכים בין threads ואין לו שום קשר להרשאות. מה שחוסם new מבחוץ הוא בנאי private.
  • final על המחלקה מספיק כדי שאף אחד לא ייצור אובייקט נוסף. final חוסם רק ירושה. אם הבנאי נשאר ציבורי, כל קוד יכול לבנות כמה אובייקטים שירצה.
  • בנאי protected יאפשר למחלקות יורשות להשתמש באותו מופע יחיד. בנאי protected נותן ליורשות דרך לבנות אובייקטים חדשים משלהן, ולכן הוא פותח פרצה בדפוס במקום לחזק אותו.
  • Singleton ו-static class הם שני שמות לאותו דבר. Singleton הוא אובייקט: אפשר להעביר אותו כארגומנט, לממש בו ממשקים ולבנות אותו רק כשצריך. static class אינה אובייקט ואינה יכולה לעשות אף אחד מאלה.
  • בתוכנית אחת יכול להיות רק Singleton אחד. ההגבלה חלה על מספר המופעים של כל מחלקה בנפרד. תוכנית יכולה להכיל כמה מחלקות Singleton, וכל אחת שומרת על המופע שלה.
בדקו את עצמכם
המחלקה AuditLog מהדוגמה היא Singleton. מתכנת במחלקה אחרת כותב new AuditLog(). מתי יתגלה שזה לא עובד, ולמה?

כבר בקומפילציה. הבנאי של AuditLog מוגדר private ולכן אינו נגיש מחוץ למחלקה, והקוד לא יגיע בכלל לשלב הריצה.

ב-C#, ה-Singleton Hub צריך לשמש גם כ-IMetrics וגם כ-INotifier. האם צריך מחלקה נפרדת לכל ממשק?

לא. Hub עצמה מממשת את שני הממשקים, ו-Hub.Instance מחזיר תמיד את אותו אובייקט. משתנה מטיפוס IMetrics ומשתנה מטיפוס INotifier מפנים שניהם אליו.

למה אי אפשר למלא את אותה דרישה בעזרת static class?

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

חזרה לתוכן העניינים

מתי נולד המופע: Eager מול Lazy

'רק אחד' ו'מתי נבנה' הן שתי החלטות נפרדות. אפשר לבנות את האובייקט מראש, ואפשר לחכות עד שמישהו יבקש אותו.

אתחול רעב (Eager Initialization): את האובייקט בונים כבר בהצהרה על השדה הסטטי. הוא נבנה כשה-JVM מאתחל את המחלקה, כלומר בשימוש הפעיל הראשון בה, ועוד לפני שמישהו ביקש אותו דרך getInstance().

Java
private static final ThemeStore STORE = new ThemeStore();   // built while the class is initialized

אתחול עצל (Lazy Initialization): השדה מתחיל כ-null, ו-getInstance() בונה את האובייקט רק כשהיא מגלה שעדיין אין כזה.

Java
final class ReportEngine {
    private static ReportEngine engine;              // null until somebody asks

    private ReportEngine() { System.out.println("ReportEngine built"); }

    public static ReportEngine getInstance() {
        if (engine == null) {                        // true only on the first call
            engine = new ReportEngine();
        }
        return engine;
    }
}

public class ReportDemo {
    public static void main(String[] args) {
        // lazy: nothing is built yet
        System.out.println("main begins");
        ReportEngine a = ReportEngine.getInstance();
        ReportEngine b = ReportEngine.getInstance();
        System.out.println(a == b);
    }
}
פלט
main begins
ReportEngine built
true

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

ולמה בכל זאת לבחור באתחול רעב? כי הוא קצר ובטוח ל-threads בלי שתכתבו נעילה.

ה-JVM (וכך גם ה-CLR ב-.NET) מבצע את האתחול הסטטי של כל מחלקה פעם אחת בלבד, תחת מנעול פנימי משלו, לפני שהמחלקה בשימוש. גם אם עשרות threads נוגעים במחלקה באותו רגע, האתחול רץ פעם אחת ונבנה אובייקט אחד.

ב-C# משיגים אותו דבר עם שדה static readonly.

המנעול הפנימי הזה שומר על הבנייה בלבד. הוא לא נלקח מחדש בכל קריאה ל-getInstance(), והוא לא הופך את המתודות של האובייקט לבטוחות כשכמה threads משתמשים בהן בו זמנית.
היבטEager (רעב)Lazy (עצל)
רגע הבנייהבאתחול המחלקה, בשימוש הפעיל הראשון בהבפעם הראשונה ש-getInstance() נקראת
בטיחות הבנייה מול threadsה-JVM או ה-CLR דואגים להבגרסה הפשוטה אין; צריך נעילה או holder
אם אף אחד לא משתמש באובייקטהוא נבנה בכל מקרההוא לא נבנה
אורך הקודשורת הצהרה אחתבדיקת null, ובדרך כלל גם נעילה
תרחיש 2: מתודה סטטית אחרת שמעירה את המופע הרעב

למחלקה הרעבה ThemeStore יש, מלבד getInstance(), גם מתודה סטטית version(). בתוכנית הבאה הפנייה הראשונה למחלקה היא דווקא ל-version():

Java
final class ThemeStore {
    private static final ThemeStore STORE = new ThemeStore();   // eager

    private ThemeStore() { System.out.println("ThemeStore built"); }

    public static ThemeStore getInstance() { return STORE; }

    public static String version() { return "v3"; }             // another static member
}

public class ThemeDemo {
    public static void main(String[] args) {
        // eager: built when the class is first used, not at program start
        System.out.println("main begins");
        System.out.println("version " + ThemeStore.version());  // first use of the class
        ThemeStore t = ThemeStore.getInstance();                // nothing new is printed here
        System.out.println(t == ThemeStore.getInstance());
    }
}
פלט
main begins
ThemeStore built
version v3
true
  1. מודפס main begins. המחלקה ThemeStore עדיין לא אותחלה.
  2. כדי להרכיב את המחרוזת "version " + ThemeStore.version() צריך לקרוא ל-version(), וזה השימוש הפעיל הראשון במחלקה. ה-JVM מאתחל אותה, השדה הסטטי נבנה ומודפס ThemeStore built.
  3. רק אחרי זה מודפסת השורה version v3.
  4. הקריאה ל-getInstance() כבר לא מדפיסה דבר, כי האובייקט קיים מהשלב השני.

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

טעויות נפוצות
  • בגרסה העצלה האובייקט נבנה כשהמערכת עולה, ובגרסה הרעבה רק לפי דרישה. הכיוון הפוך. 'רעב' בונה מראש, באתחול המחלקה; 'עצל' מחכה לבקשה הראשונה.
  • אתחול רעב דורש Mutex, ואילו הגרסה העצלה לא צריכה הגנה. גם זה הפוך. הגרסה הרעבה מוגנת מעצם היותה אתחול סטטי, והגרסה העצלה הפשוטה היא זו שחשופה למרוץ בין threads.
  • הטעם באתחול עצל הוא לאפשר כמה מופעים, כל אחד כשצריך אותו. עצלות משנה רק את התזמון. עדיין נבנה אובייקט אחד, בבקשה הראשונה.
  • בגרסה הרעבה, threads נכנסים ל-getInstance() אחד-אחד, כי ה-JVM מחזיק מנעול סביב המתודה לאורך כל הריצה. המנעול הפנימי חל רק על האתחול הסטטי, שרץ פעם אחת. אחריו הקריאות מחזירות את השדה בלי שום מנעול.
  • כיוון שהאובייקט נבנה באתחול סטטי, כל המתודות שלו בטוחות לשימוש מקבילי. האתחול הסטטי מגן על רגע הבנייה ותו לא. אם לאובייקט יש מצב שמשתנה, המתודות שניגשות אליו צריכות סנכרון משלהן.
  • באתחול עצל אין צורך בשדה סטטי, כי האובייקט נבנה בתוך המתודה. בלי שדה static אין איפה לשמור את האובייקט בין קריאה לקריאה, וכל קריאה הייתה בונה אחד חדש.
בדקו את עצמכם
בניית PdfRenderer טוענת גופנים ולוקחת זמן רב, ורק מעט משתמשים מפיקים PDF. איזה אתחול מתאים?

אתחול עצל. האובייקט ייבנה רק אצל מי שיבקש אותו בפועל, והשאר לא ישלמו את העלות.

שדה private static final מאותחל ישירות בהצהרה. למה לא נבנים שני אובייקטים גם כשכמה threads פונים למחלקה באותו רגע?

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

במחלקה רעבה יש גם מתודה סטטית describe(). אם התוכנית קוראת רק ל-describe() ולא ל-getInstance(), האם האובייקט נבנה?

כן. הקריאה מאתחלת את המחלקה, ואתחול המחלקה כולל את בניית האובייקט שבשדה הסטטי.

חזרה לתוכן העניינים

Singleton כשכמה threads רצים יחד

thread (שרשור, או תהליכון) הוא רצף ביצוע עצמאי בתוך התוכנית. כמה threads של אותו תהליך רצים במקביל ורואים את אותו זיכרון, ובכלל זה את השדות הסטטיים של המחלקות.

כאן נשברת הגרסה העצלה הפשוטה. נניח ששני threads, R ו-S, קוראים יחד ל-getInstance() של ReportEngine:

  1. R בודק engine == null ומקבל true.
  2. לפני ש-R מספיק לבנות, המעבד עובר ל-S, וגם הוא בודק ומקבל true.
  3. R בונה אובייקט ושומר אותו בשדה.
  4. S, שכבר עבר את הבדיקה, בונה אובייקט שני ודורס את השדה.

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

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

דרך 1: synchronized על מתודת הגישה.

Java
final class IdGenerator {
    private static IdGenerator gen;

    private IdGenerator() { System.out.println("IdGenerator built"); }

    public static synchronized IdGenerator getInstance() {   // lock = IdGenerator.class
        if (gen == null) {
            gen = new IdGenerator();
        }
        return gen;
    }
}

כשמסמנים מתודה סטטית ב-synchronized, המנעול שנלקח הוא אובייקט ה-Class של המחלקה, כאן IdGenerator.class. יש מנעול אחד כזה לכל ה-threads, ולכן בכל רגע רק אחד מהם נמצא בתוך המתודה: הראשון בונה, וכל מי שנכנס אחריו מוצא אובייקט מוכן.

המחיר: המנעול נלקח בכל קריאה, גם אלף קריאות אחרי שהאובייקט כבר קיים, וזה מורגש בקוד שמבקש אותו לעתים קרובות. ב-C# כותבים את אותו רעיון עם בלוק lock.

דרך 2: Double-Checked Locking (נעילה עם בדיקה כפולה).

Java
final class PluginRegistry {
    private static volatile PluginRegistry registry;   // volatile is not optional here

    private PluginRegistry() { System.out.println("registry built"); }

    public static PluginRegistry getInstance() {
        if (registry == null) {                         // fast path: no lock once it exists
            synchronized (PluginRegistry.class) {
                if (registry == null) {                 // re-check after getting the lock
                    registry = new PluginRegistry();
                }
            }
        }
        return registry;
    }
}

public class RegistryDemo {
    public static void main(String[] args) {
        PluginRegistry[] seen = new PluginRegistry[8];
        Thread[] ts = new Thread[8];
        for (int i = 0; i < 8; i++) {
            final int k = i;
            ts[i] = new Thread(() -> seen[k] = PluginRegistry.getInstance());
            ts[i].start();
        }
        for (Thread t : ts) {
            try { t.join(); } catch (InterruptedException e) { return; }   // wait for every thread
        }
        boolean allSame = true;
        for (PluginRegistry r : seen) allSame &= (r == seen[0]);
        System.out.println("all 8 threads got the same object: " + allSame);
    }
}
פלט
registry built
all 8 threads got the same object: true

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

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

volatile על השדה: בלעדיו, thread אחר עלול לקרוא מהשדה הפניה שאינה null לאובייקט שהבנאי שלו עוד לא סיים, ולעבוד עם אובייקט חצי מוכן. ה-JVM לא מתחייב שערך שנכתב ב-thread אחד ייראה מיד ובשלמותו ב-thread אחר, אלא אם יש volatile או נעילה. מ-Java 5 ואילך volatile מספיק כדי שהדפוס יהיה תקין.

בפלט רואים ריצה שבה כל שמונת ה-threads קיבלו אותו אובייקט. ריצה תקינה אחת אינה הוכחה, כי מרוץ יכול להופיע רק לעתים רחוקות; הנכונות נובעת מהניתוח שלמעלה.

דרך 3: Initialization-on-demand holder (מחלקה מקוננת שמחזיקה את המופע).

Java
final class GeoIndex {
    private GeoIndex() { System.out.println("GeoIndex built"); }

    private static class Keeper {                    // initialized on first use only
        static final GeoIndex INDEX = new GeoIndex();
    }

    public static GeoIndex getInstance() { return Keeper.INDEX; }

    public static void ping() { System.out.println("ping, the index does not exist yet"); }
}

public class Main {
    public static void main(String[] args) {
        GeoIndex.ping();                             // loads GeoIndex, not Keeper
        GeoIndex g1 = GeoIndex.getInstance();        // now Keeper is initialized
        GeoIndex g2 = GeoIndex.getInstance();
        System.out.println(g1 == g2);
    }
}
פלט
ping, the index does not exist yet
GeoIndex built
true

המחלקה המקוננת Keeper מאותחלת רק כשמישהו פונה אליה, וזה קורה רק בתוך getInstance(). הקריאה ל-ping() טוענת ומאתחלת את GeoIndex, אבל לא את Keeper, ולכן האובייקט עדיין לא קיים.

הבנייה מתרחשת באתחול הסטטי של Keeper, שה-JVM מריץ פעם אחת תחת מנעול משלו. מקבלים בנייה עצלה ובטוחה ל-threads, בלי synchronized ובלי volatile בקוד שלכם. המהדר לא מוסיף שום נעילה למחלקה המקוננת: הבטיחות כולה באה ממנגנון אתחול המחלקות של ה-JVM.

דרך 4: enum עם ערך יחיד. כל ערך של enum הוא קבוע (constant), ולכן ל-enum כזה יש קבוע אחד ויחיד.

Java
enum TicketCounter {
    INSTANCE;                                        // the only value, so the only object

    private int next = 100;

    public int take() { return next++; }
}

public class TicketDemo {
    public static void main(String[] args) {
        System.out.println(TicketCounter.INSTANCE.take());
        System.out.println(TicketCounter.INSTANCE.take());
    }
}
פלט
100
101

הספר Effective Java ממליץ על הצורה הזו: היא בטוחה ל-threads, וכפי שנראה מיד, היא עומדת גם מול Reflection וגם מול serialization.

ב-C#, Lazy<T> (כמו ב-Hub שלמעלה) מוגן מפני threads כבר בהגדרות ברירת המחדל שלו (המצב LazyThreadSafetyMode.ExecutionAndPublication). אפשרות נוספת היא lock עם בדיקה כפולה, באותו היגיון כמו ב-Java.

בנייה בטוחה אינה שימוש בטוח. כל הדרכים האלה מבטיחות שייבנה אובייקט אחד, ולא יותר. אם לאובייקט יש מצב שמשתנה (מונה, רשימה, מטמון), מתודות שכמה threads קוראים להן במקביל צריכות הגנה משלהן, למשל lock, synchronized או Mutex. לדוגמה, take() של TicketCounter אינה מסונכרנת, ושני threads עלולים לקבל ממנה אותו מספר.
תרחיש 3: שני threads עוברים דרך הבדיקה הכפולה

PluginRegistry עדיין לא נבנה, ושני threads, P ו-Q, קוראים ל-getInstance() באותו רגע.

  1. P ו-Q מבצעים את הבדיקה החיצונית, ושניהם רואים null.
  2. P משיג את המנעול של PluginRegistry.class; Q נעצר בפתח הבלוק.
  3. P בודק שוב, השדה עדיין null, בונה את האובייקט, כותב אותו לשדה ומשחרר את המנעול.
  4. Q נכנס, מבצע את הבדיקה הפנימית ומגלה שהשדה כבר מלא. הוא לא בונה כלום.
  5. מכאן והלאה כל קריאה נעצרת בבדיקה החיצונית ומחזירה את האובייקט בלי לגעת במנעול.

אם מוחקים את הבדיקה הפנימית, בשלב 4 Q היה בונה אובייקט שני. אם מוחקים את volatile, thread שלישי שמגיע בזמן שלב 3 עלול לקרוא מהשדה הפניה לאובייקט שעוד לא סיים להיבנות.

טעויות נפוצות
  • בנאי private מספיק כדי שייבנה אובייקט אחד גם כשכמה threads קוראים ל-getInstance(). שני threads שמריצים קוד בתוך המחלקה רשאים להפעיל את הבנאי הפרטי. אם שניהם ראו null, שניהם יבנו.
  • בדיקת if (instance == null) לפני הבנייה פותרת את הבעיה. ייתכן ששני threads יראו null בבדיקה עוד לפני שמישהו מהם סיים לבנות. הבדיקה והבנייה אינן פעולה אחת.
  • פותרים את ההתנגשות בכך שכל thread מקבל אובייקט משלו. אז יש כמה אובייקטים, וזה כבר אינו Singleton.
  • בבדיקה כפולה אפשר להשאיר את השדה רגיל, כי ה-JVM מראה ערכים חדשים לכל ה-threads מיד. ה-JVM לא מבטיח זאת. בלי volatile thread אחר עלול לראות אובייקט שבנייתו לא הושלמה.
  • אפשר להחליף את synchronized ב-try-catch סביב הבנייה. תפיסת חריגות לא קשורה לסנכרון. שני threads יבנו שני אובייקטים בלי שתיזרק חריגה כלשהי.
  • הבדיקה החיצונית הופכת את הבדיקה הפנימית למיותרת. הפנימית נחוצה בדיוק למקרה ששני threads עברו יחד את החיצונית וחיכו בתור למנעול.
  • הבדיקה החיצונית נועדה לוודא שה-class loader כבר טען את המחלקה. המטרה שלה היא חיסכון: אחרי שהאובייקט קיים, הקריאה חוזרת בלי לקחת את המנעול.
  • הבדיקה החיצונית קיימת כדי שהנעילה תילקח בכל קריאה. ההפך: היא קיימת כדי שבקריאות שאחרי הבנייה לא תילקח נעילה בכלל.
  • ב-holder האובייקט נבנה כבר כשהמחלקה החיצונית נטענת. הוא נבנה באתחול המחלקה המקוננת, ואת האתחול הזה מפעילה רק הפנייה הראשונה של getInstance() אל Keeper. קריאה למתודה סטטית אחרת של המחלקה החיצונית לא בונה אותו.
  • ב-holder המהדר מוסיף מאחורי הקלעים synchronized למחלקה המקוננת. המהדר לא מוסיף שום נעילה. הבטיחות נובעת מכך שה-JVM מאתחל כל מחלקה פעם אחת תחת מנעול פנימי.
  • ב-holder אין מופעים נוספים כי המחלקה המקוננת מוגדרת private. private על המחלקה המקוננת רק מסתיר אותה. מה שחוסם יצירה מבחוץ הוא הבנאי הפרטי של המחלקה החיצונית, ומה שמבטיח בנייה אחת הוא אתחול המחלקה ב-JVM.
  • Singleton הופך כל גישה למשאב המשותף לבטוחה בין threads, בלי סנכרון נוסף. הדפוס עוסק במספר המופעים. מתודות שמשנות מצב משותף צריכות סנכרון משלהן.
בדקו את עצמכם
בגרסת הבדיקה הכפולה של PluginRegistry מוחקים את ה-if שבתוך הבלוק synchronized. מה עלול לקרות?

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

בגרסת ה-holder של GeoIndex, התוכנית קוראת עשר פעמים ל-GeoIndex.ping() ואף פעם לא ל-getInstance(). כמה פעמים יודפס GeoIndex built?

אף פעם. ping() מאתחלת רק את GeoIndex, והאובייקט נבנה באתחול של Keeper, שאיש לא פנה אליה.

למה synchronized על getInstance() פותר את המרוץ, ומה המחיר שלו?

כל ה-threads נועלים את אותו מנעול (IdGenerator.class), ולכן הבדיקה והבנייה מתבצעות בכל פעם בידי thread אחד בלבד. המחיר: הנעילה נלקחת בכל קריאה, גם אחרי שהאובייקט כבר קיים.

חזרה לתוכן העניינים

פרצות בדפוס ואיך סוגרים אותן

הבנאי הפרטי עוצר קוד רגיל שכותב new. ארבעה מנגנונים עוקפים אותו בלי לכתוב new בכלל:

מנגנוןאיך נוצר אובייקט נוסףאיך מתגוננים
Reflectionקוד מבקש את הבנאי הפרטי, קורא עליו setAccessible(true) ובונה דרכו אובייקטהגנה חלקית: בנאי שזורק חריגה אם האובייקט כבר קיים. הגנה מלאה: enum, כי ניסיון לבנות ערך enum דרך Reflection נכשל ב-IllegalArgumentException
Serializationשחזור (deserialization) של אובייקט שנשמר בונה אובייקט חדשלהגדיר במחלקה readResolve שמחזירה את המופע הקיים; ב-enum זה קורה מעצמו
Cloningאם המחלקה מממשת Cloneable, הקריאה ל-clone משכפלת את האובייקטפשוט לא לממש Cloneable
כמה class loadersכל class loader טוען עותק נפרד של המחלקה, ולכל עותק אובייקט משלולזכור שההבטחה היא אובייקט אחד לכל class loader

כך זה נראה בפועל, ב-Java 8:

Java
import java.lang.reflect.Constructor;

final class KeyStore {
    private static final KeyStore STORE = new KeyStore();
    private KeyStore() { }
    public static KeyStore getInstance() { return STORE; }
}

enum KeyRing { INSTANCE }

public class ReflectionDemo {
    public static void main(String[] args) throws ReflectiveOperationException {
        Constructor<KeyStore> c = KeyStore.class.getDeclaredConstructor();
        c.setAccessible(true);                           // switch off the private check
        KeyStore extra = c.newInstance();
        System.out.println(extra == KeyStore.getInstance());

        Constructor<KeyRing> e = KeyRing.class.getDeclaredConstructor(String.class, int.class);
        e.setAccessible(true);
        try {
            e.newInstance("COPY", 1);
        } catch (IllegalArgumentException ex) {
            System.out.println("enum refused: " + ex.getMessage());
        }
    }
}
פלט
false
enum refused: Cannot reflectively create enum objects

מול KeyStore הרגילה, Reflection הצליח לבנות אובייקט שני, וההשוואה נותנת false. מול ה-enum KeyRing אותו ניסיון נדחה בחריגה.

ויש פרצה חמישית, הקלה ביותר לסגירה: ירושה. אם הבנאי protected או public, מחלקה יורשת יכולה להפעיל אותו דרך super() ולבנות כמה אובייקטים שתרצה מהטיפוס שלה, וכל אחד מהם הוא גם מופע של מחלקת ה-Singleton. היא גם יכולה לדרוס מתודות ולשנות את ההתנהגות של מה שאמור להיות 'האובייקט היחיד'.

הסגירה: בנאי private יחד עם final על המחלקה (ב-C#: sealed). אין תת-מחלקה, ולכן גם אין דריסה.

טעויות נפוצות
  • בנאי protected ימנע ממחלקות אחרות לדרוס את המתודות. בנאי protected עושה את ההפך: הוא מאפשר ירושה, ואיתה גם דריסה ובנייה של מופעים נוספים.
  • אם כל המתודות יוגדרו abstract, אי אפשר יהיה לדרוס אותן. abstract פירושה 'חובה לדרוס'. יתרה מזו, מחלקה עם מתודה אבסטרקטית נעשית אבסטרקטית, ואז אי אפשר ליצור ממנה אפילו את המופע האחד.
  • מתודות protected חסומות לדריסה. protected קובעת רק מי רשאי לגשת. מחלקה יורשת יכולה לדרוס מתודת protected בלי בעיה.
  • הגדרת getInstance() כ-abstract תחייב כל יורשת לספק גרסה משלה, וכך הדפוס מוגן. מתודה סטטית אינה יכולה להיות abstract ב-Java, ובכל מקרה זה לא היה מונע אובייקטים נוספים.
  • אם הבנאי public, הדפוס נשמר, כי רק יורשות ישתמשו בו, דרך super(). בנאי public פתוח לכל קוד, לא רק ליורשות, וכל אחד יכול לבנות אובייקטים חדשים.
בדקו את עצמכם
צוות רוצה לוודא שאף אחד לא יכתוב תת-מחלקה של ה-Singleton שלו ולא ידרוס את המתודות. מה מתאים: לסמן את המחלקה final, או לתת לכל המתודות הרשאת protected?

final על המחלקה. הוא חוסם ירושה לגמרי, ובלי יורשת אין דריסה. protected לא מונע דריסה כלל.

איזו צורת Singleton ב-Java עומדת גם מול Reflection וגם מול serialization, בלי שתכתבו קוד הגנה?

enum עם ערך אחד. Reflection נכשל בניסיון לבנות ערך enum, ובשחזור ה-JVM מחזיר את הערך הקיים.

חזרה לתוכן העניינים

המחיר של Singleton: מצב גלובלי, תלות סמויה ובדיקות

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

  • מצב גלובלי שלא נעלם. שדה סטטי מחזיק הפניה לאובייקט, ולכן ה-Garbage Collector לא אוסף אותו והוא חי עד סוף הריצה. כל שינוי שקוד אחד עושה בו נשאר ומשפיע על כל קוד אחר.
  • תלות שלא רואים. מחלקה שקוראת ל-Hub.Instance (או ל-getInstance()) באמצע מתודה תלויה ב-Hub, אבל אין לכך זכר בבנאי שלה או בפרמטרים שלה. מי שקורא רק את החתימות לא יודע שהתלות קיימת.
  • בדיקות יחידה שאינן עצמאיות. בדיקת יחידה (Unit Test) אמורה לעמוד בפני עצמה. כאן בדיקה שמשנה את מצב האובייקט מורישה את השינוי לבדיקה הבאה, כי שתיהן מקבלות אותו אובייקט. בנוסף, קשה להחליף אותו בתחליף (Mock).
  • המחלקה מנהלת את מחזור החיים של עצמה, במקום שקוד חיצוני יחליט מתי היא נבנית ומי מקבל אותה.
שימו לב למה שחסר ברשימה. AuditLog מתחילת הפרק הוא אובייקט רגיל לחלוטין, והוא לא צורך יותר זיכרון מכל אובייקט אחר שיש לו אותם שדות. וריבוי threads אינו סיבה לוותר עליו: ראיתם שהגרסה הרעבה, ה-holder וה-enum נבנים בבטחה גם כשכמה threads מבקשים אותם יחד.

הפתרון המקובל מפריד בין שתי שאלות: 'כמה מופעים יש' ו'איך הקוד מקבל את המופע'.

  1. מגדירים ממשק שמתאר את מה שהאובייקט עושה.
  2. הקוד שמשתמש באובייקט תלוי בממשק בלבד ומקבל את המופע מבחוץ, בדרך כלל בבנאי. זו הזרקת תלות (Dependency Injection).
  3. בריצה האמיתית מעבירים את ה-Singleton; בבדיקה מעבירים מימוש דמה של אותו ממשק.

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

C#
// production: the real single instance is handed in
new Invoice(Hub.Instance).Close(250);

// test: a recording fake goes in through the same door
var probe = new RecordingNotifier();
new Invoice(probe).Close(90);
Console.WriteLine("probe recorded: " + probe.Messages.Count + " message(s), last = " + probe.Messages[^1]);

interface INotifier { void Notify(string text); }

sealed class Hub : INotifier {
    private static readonly Lazy<Hub> holder = new Lazy<Hub>(() => new Hub());
    public static Hub Instance => holder.Value;
    private Hub() { }
    public void Notify(string text) { Console.WriteLine("notify " + text); }
}

class Invoice {
    private readonly INotifier notifier;
    public Invoice(INotifier notifier) { this.notifier = notifier; }  // the dependency is visible here
    public void Close(int amount) { notifier.Notify("invoice closed: " + amount); }
}

class RecordingNotifier : INotifier {                                // test double, prints nothing
    public List<string> Messages { get; } = new List<string>();
    public void Notify(string text) { Messages.Add(text); }
}
פלט
notify invoice closed: 250
probe recorded: 1 message(s), last = invoice closed: 90
תרחיש 4: בדיקות שעוברות כל אחת לבד ונכשלות יחד

Cart היא Singleton שסופרת פריטים. בדיקה X מוסיפה שלושה פריטים ומצפה לספירה 3. בדיקה Y מוסיפה פריט אחד ומצפה לספירה 1.

  • כשמריצים רק את X: הספירה 3, והבדיקה עוברת.
  • כשמריצים רק את Y: הספירה 1, והבדיקה עוברת.
  • כשמריצים את X ואחריה את Y באותה ריצה: Y מקבלת את אותו אובייקט, שכבר מכיל שלושה פריטים. הספירה 4, והבדיקה נכשלת.

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

טעויות נפוצות
  • מסגרות בדיקה לא מסוגלות לעבוד עם מחלקה שהבנאי שלה פרטי. הן עובדות איתה. הקושי הוא המצב המשותף שעובר בין בדיקות, והעובדה שאי אפשר להחליף את המופע בתחליף.
  • כשבדיקה מסתיימת, מנגנון איסוף הזבל מפנה את ה-Singleton, והבדיקה הבאה מתחילה נקי. השדה הסטטי ממשיך להחזיק בו, ולכן הוא לא נאסף והמצב שלו נשמר.
  • בכל בדיקה חדשה getInstance() מחזירה עותק טרי. זה בדיוק מה שהדפוס מונע: כל קריאה מחזירה את אותו אובייקט.
  • פתרון טוב לבדיקות: לפני כל בדיקה, לפרוץ בכוח עם Reflection אל ה-static הפרטי ולהציב בו null. זה עוקף את הדפוס בכוח ושביר מאוד. הפתרון העיצובי הוא ממשק והזרקה.
  • פתרון טוב: מתודת setInstance שמציבה בשדה אובייקט אחר מאותה מחלקה בדיוק. אובייקט נוסף מאותה מחלקה אינו תחליף, והקוד ממשיך להיות קשור למחלקה הקונקרטית.
  • פתרון טוב: לוותר על ה-Singleton לטובת מחלקה סטטית או שדה public static. זה אותו מצב גלובלי בלבוש אחר, ומתודות סטטיות אף אינן ניתנות לדריסה, כך שאי אפשר להחליף אותן ב-Mock.
  • הקושי נובע מכך שב-C# אי אפשר לכתוב בנאי פרטי. ב-C# אפשר בהחלט להגדיר בנאי private, כמו ב-Hub.
  • כל פנייה ל-Singleton משלמת על מנעול, וזה מה שהופך אותו לאיטי. בגרסה הרעבה וב-holder אין נעילה בקריאה. רק גרסת synchronized על המתודה נועלת בכל פעם.
  • Singleton בעייתי כי הוא תופס הרבה זיכרון. אובייקט יחיד אינו כבד יותר מכל אובייקט אחר. הבעיות הן מצב גלובלי, תלות סמויה וקושי בבדיקות.
בדקו את עצמכם
המחלקה Shipping קוראת בתוך המתודות שלה ל-TaxTable.getInstance(). מה מוסתר כאן ממי שקורא את הקוד?

תלות ב-TaxTable שלא מופיעה בבנאי של Shipping ולא בפרמטרים של המתודות שלה. אי אפשר לדעת עליה מהחתימות, ואי אפשר להחליף אותה מבחוץ.

מה צריך לשנות ב-Shipping כדי שתוכלו לבדוק אותה עם טבלת מסים מזויפת?

להגדיר ממשק לטבלת המסים, ולתת ל-Shipping לקבל מימוש שלו בבנאי. בריצה רגילה מעבירים את ה-Singleton, ובבדיקה מעבירים מימוש דמה.

חזרה לתוכן העניינים

Constructor: הקוד שבונה את האובייקט

על מה הבנאי אחראי ומתי הוא מופעל

בנאי (Constructor) הוא קוד מיוחד במחלקה שמכין אובייקט שזה עתה נוצר: מציב ערכים התחלתיים בשדות ומביא אותו למצב שאפשר לעבוד איתו. הוא רץ באותו רגע שבו מתבצע new.

Java
class Ticket {
    String code;
    int seat;

    Ticket(String code, int seat) {   // class name, and no return type at all
        this.code = code;             // left: the field, right: the parameter
        this.seat = seat;
        System.out.println("ticket " + code + " seat " + seat);
    }
}

public class Main {
    public static void main(String[] args) {
        Ticket t;                          // only a variable, no object, nothing runs
        System.out.println("declared");
        t = new Ticket("TLV-9", 14);       // the constructor runs here
        System.out.println(t.seat);
    }
}
פלט
declared
ticket TLV-9 seat 14
14

שלושה סימנים מזהים בנאי:

  • השם שלו זהה לשם המחלקה, אות באות.
  • אין לו טיפוס החזרה בכלל, אפילו לא void.
  • הוא לא 'מחזיר' את האובייקט. new מקצה את הזיכרון, הבנאי ממלא את השדות, ובסוף new הוא שמחזיר את ההפניה.

מאותו פלט אפשר ללמוד גם מתי הבנאי לא רץ:

  • בהצהרה על משתנה: Ticket t; רק יוצרת משתנה שעדיין לא מפנה לשום אובייקט, ולכן declared מודפס לפני ההודעה של הבנאי.
  • באתחול המחלקה: כשה-JVM טוען ומאתחל מחלקה, רצים בלוקי static { } ואתחולי השדות הסטטיים שלה, ולא הבנאי.
  • בקריאות למתודות: הבנאי רץ פעם אחת לכל אובייקט, ביצירה, ולא בכל שימוש בו.

מלכודת ב-Java: מספיק להוסיף טיפוס החזרה, וה'בנאי' הופך למתודה רגילה שבמקרה נושאת את שם המחלקה.

Java
class Badge {
    void Badge() {                         // has a return type, so it is an ordinary method
        System.out.println("Badge() as a method");
    }
}

public class BadgeDemo {
    public static void main(String[] args) {
        Badge b = new Badge();             // uses the compiler's default constructor
        System.out.println("object created");
        b.Badge();                         // runs only when called like any method
    }
}
פלט
object created
Badge() as a method

הקוד מתקמפל, כי למחלקה בלי בנאים המהדר מוסיף בנאי ריק. new Badge() לא מדפיס דבר, והמתודה Badge() רצה רק כשקוראים לה במפורש. ב-C# אותו דבר הוא שגיאת קומפילציה:

C#
class Badge {
    public void Badge() { }   // a method carrying the class name
}
פלט
Program.cs(2,17): error CS0542: 'Badge': member names cannot be the same as their enclosing type

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

ואם הבנאי זורק חריגה, new לא מחזיר אובייקט, וההשמה למשתנה פשוט לא מתבצעת:

Java
class Account {
    int balance;
    Account(int opening) {
        if (opening < 0) throw new IllegalArgumentException("negative opening balance");
        balance = opening;
    }
}

public class Main {
    public static void main(String[] args) {
        Account acc = null;
        try {
            acc = new Account(-40);
        } catch (IllegalArgumentException e) {
            System.out.println("failed: " + e.getMessage());
        }
        System.out.println(acc == null);   // the assignment never happened
    }
}
פלט
failed: negative opening balance
true
טעויות נפוצות
  • בנאי מוצהר עם void, כמו כל מתודה שלא מחזירה ערך. ברגע שיש void (או כל טיפוס החזרה אחר), זו מתודה רגילה ולא בנאי.
  • הבנאי מחזיר הפניה לאובייקט החדש. לבנאי אין ערך החזרה. את ההפניה מחזיר new.
  • מגדירים בנאי static כדי שירוץ עוד לפני שיש מופע. ב-Java בנאי לא יכול להיות static, וגם לא abstract, final או synchronized. ב-C# קיים בנאי סטטי, אבל זה מנגנון אחר שנראה בהמשך.
  • הבנאי מופעל כשה-JVM טוען את המחלקה. בטעינה ובאתחול של מחלקה רץ רק הקוד הסטטי שלה. הבנאי רץ בכל new.
  • הבנאי מופעל בקריאה הראשונה למתודה של האובייקט. כשאפשר לקרוא למתודה, האובייקט כבר קיים והבנאי שלו כבר סיים.
  • הבנאי הוא המקום שבו האובייקט מתפרק ומחזיר קבצים וזיכרון למערכת. זה הפוך: הבנאי מאתחל.
  • דרך הבנאי מחליטים מה קוד חיצוני רשאי להפעיל על האובייקט. הנגישות נקבעת בהרשאת הגישה (public, private וכדומה) של כל חבר.
בדקו את עצמכם
בקוד מופיעה השורה Printer p; ואחריה p = new Printer();. איפה בדיוק רץ הבנאי של Printer?

בשורה השנייה, בביצוע new. השורה הראשונה רק מצהירה על משתנה ולא יוצרת אובייקט.

במחלקה Clock כתוב רק int Clock() { return 0; }. האם new Clock() מתקמפל ב-Java?

כן. int Clock() היא מתודה רגילה, ולכן אין למחלקה בנאים, והמהדר מוסיף לה בנאי ברירת מחדל. ב-C# אותו קוד היה נכשל בשגיאה CS0542.

חזרה לתוכן העניינים

הבנאי שהמהדר כותב בשבילכם

כשמחלקה לא מצהירה על אף בנאי, המהדר מוסיף לה בנאי בלי פרמטרים. זה בנאי ברירת המחדל (Default Constructor).

ב-Java הרשאת הגישה שלו זהה להרשאה של המחלקה עצמה, כך שמחלקה public מקבלת בנאי public. ב-C# הוא public, ובמחלקה אבסטרקטית protected.

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

Java
class Coupon {
    int percent;
    Coupon(int percent) { this.percent = percent; }   // the class now has exactly one constructor
}

class Shop {
    Coupon blank = new Coupon();                      // asks for a no-argument constructor
}
פלט
Shop.java:7: error: constructor Coupon in class Coupon cannot be applied to given types;
    Coupon blank = new Coupon();                      // asks for a no-argument constructor
                   ^
  required: int
  found: no arguments
  reason: actual and formal argument lists differ in length
1 error

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

אם צריך גם new Coupon() וגם new Coupon(15), כותבים בעצמכם בנאי בלי פרמטרים לצד הבנאי הקיים.

בנאים לא עוברים בירושה. העובדה שלמחלקת האב יש Coupon(int) לא נותנת בנאי כזה למחלקה שיורשת ממנה.
טעויות נפוצות
  • המהדר מוסיף בנאי בלי פרמטרים לכל מחלקה, גם כשכבר יש בה בנאי אחר. רק למחלקה שאין בה אף בנאי מוצהר.
  • בנאי ברירת מחדל הוא בנאי שנכתב בלי מילת הרשאה, ולכן נגיש רק בתוך החבילה. המונח מתאר בנאי שהמהדר יוצר כשאין אחר. ההרשאה שלו נגזרת מההרשאה של המחלקה.
  • בנאי ברירת מחדל הוא הבנאי שהמחלקה מקבלת בירושה מהאב. בנאים אינם עוברים בירושה בכלל.
  • new עם פחות ארגומנטים יתקמפל, ובזמן ריצה תיזרק חריגה. המהדר מזהה שאין בנאי מתאים ועוצר כבר בקומפילציה.
  • החסר יושלם בערך ברירת מחדל, והאובייקט ייבנה עם null או 0. Java אינה ממלאת ארגומנטים חסרים. בלי בנאי מתאים אין אובייקט.
בדקו את עצמכם
למחלקה Fan לא היה שום בנאי, והקוד השתמש ב-new Fan() בכמה מקומות. עכשיו מוסיפים לה Fan(int speed). מה קורה לקריאות הישנות?

הן מפסיקות להתקמפל. מרגע שיש בנאי מוצהר, המהדר כבר לא מוסיף את הבנאי בלי הפרמטרים. כדי לשמור עליהן צריך לכתוב Fan() במפורש.

חזרה לתוכן העניינים

כמה בנאים באותה מחלקה ושרשור עם this(...)

מחלקה רשאית להחזיק כמה בנאים, בתנאי שרשימות הפרמטרים שלהם שונות. זו העמסה (Overloading) של בנאים, והיא נותנת למי שבונה אובייקט כמה דרכים נוחות לעשות זאת.

כדי שקוד האתחול לא ייכתב שלוש פעמים, בנאי יכול להעביר את העבודה לבנאי נוסף באותה מחלקה. ב-Java כותבים this(...), ובכלל הקלאסי זו חייבת להיות ההוראה (statement) הראשונה בגוף הבנאי.

Java
class Shipment {
    String city;
    int kilos;
    boolean express;

    Shipment(String city) {
        this(city, 1);                       // delegate; has to be the first statement
    }

    Shipment(String city, int kilos) {
        this(city, kilos, false);
    }

    Shipment(String city, int kilos, boolean express) {   // the one place that assigns
        this.city = city;
        this.kilos = kilos;
        this.express = express;
    }

    public String toString() { return city + "/" + kilos + "kg/" + (express ? "express" : "regular"); }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Shipment("Haifa"));
        System.out.println(new Shipment("Eilat", 12));
        System.out.println(new Shipment("Acre", 3, true));
    }
}
פלט
Haifa/1kg/regular
Eilat/12kg/regular
Acre/3kg/express

רק הבנאי בעל שלושת הפרמטרים מציב ערכים; האחרים משלימים ערך חסר ומעבירים הלאה. כשמכניסים הוראה לפני this(...), Java 8 מסרבת:

Java
class Shipment {
    String city;
    int kilos;

    Shipment(String city) {
        System.out.println("checking " + city);
        this(city, 1);                       // not the first statement any more
    }

    Shipment(String city, int kilos) {
        this.city = city;
        this.kilos = kilos;
    }
}
פלט
Main.java:7: error: call to this must be first statement in constructor
        this(city, 1);                       // not the first statement any more
            ^
1 error
החל מ-Java 25 (Flexible Constructor Bodies) מותר לכתוב הוראות לפני this(...) או super(...), כל עוד הן לא נוגעות באובייקט שבבנייה, והדוגמה שלמעלה הייתה מתקמפלת שם. השאלות מניחות את הכלל הקלאסי, אלא אם כתוב בהן במפורש Java 25.

ב-C# הקריאה לבנאי אחר של המחלקה לא נמצאת בגוף אלא בכותרת, אחרי נקודתיים:

C#
Console.WriteLine(new Shipment("Haifa"));
Console.WriteLine(new Shipment("Eilat", 12));

class Shipment {
    public string City;
    public int Kilos;

    public Shipment(string city) : this(city, 1) { }    // the call sits in the header

    public Shipment(string city, int kilos) {
        City = city;
        Kilos = kilos;
    }

    public override string ToString() => City + "/" + Kilos + "kg";
}
פלט
Haifa/1kg
Eilat/12kg

שלוש צורות שנראות כמו שרשור ואינן:

  • super(...) פונה לבנאי של מחלקת האב, לא לבנאי אחר באותה מחלקה.
  • new Shipment(city, 1) בתוך בנאי בונה אובייקט שני ונפרד, שנזרק מיד, והאובייקט הנוכחי נשאר לא מאותחל.
  • Shipment(city, 1); בלי this אינו תחביר חוקי לקריאה לבנאי.

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

תרחיש 5: שרשרת של שלושה בנאים ב-Tile
Java
class Tile {
    Tile() {
        this(3);
        System.out.print("M");
    }
    Tile(int a) {
        this(a, a * a);
        System.out.print("N");
    }
    Tile(int a, int b) {
        System.out.print(a * b);
    }
}

public class TileDemo {
    public static void main(String[] args) {
        new Tile();
        System.out.println();
    }
}
פלט
27NM
  1. new Tile() נכנס לבנאי בלי הפרמטרים, והשורה הראשונה שלו היא this(3).
  2. Tile(3) מחשב 3 * 3 ומעביר מיד ל-this(3, 9).
  3. Tile(3, 9) מדפיס את המכפלה, 27, ומסתיים.
  4. השליטה חוזרת ל-Tile(3), שממשיך להדפסה שלו: N.
  5. השליטה חוזרת ל-Tile(), שמדפיס M.

מי שקורא את הקוד מלמעלה למטה כמו רשימת הוראות יענה בטעות M, N ואז 27. הסדר האמיתי הפוך.

טעויות נפוצות
  • כשבנאי רוצה להיעזר בבנאי נוסף באותה מחלקה, הוא כותב super(...). super(...) מוביל למחלקת האב. לבנאי באותה מחלקה פונים עם this(...).
  • כדי להשתמש בבנאי אחר כותבים בתוך הבנאי new עם הארגומנטים המתאימים. זה בונה אובייקט נוסף ולא מאתחל את האובייקט הנוכחי.
  • אפשר להפעיל בנאי נוסף באותה מחלקה בשמו, למשל Tile(3);. זה לא תחביר חוקי. הצורה היחידה היא this(...).
  • this(...) יכולה להופיע בכל מקום בגוף הבנאי. בכלל הקלאסי היא חייבת להיות ההוראה הראשונה, אחרת המהדר מתריע call to this must be first statement in constructor.
  • בשרשרת, הבנאי שנקרא ראשון גם מדפיס ראשון. כל בנאי ממשיך לשורות שאחרי this(...) רק אחרי שהבנאי שהוא קרא לו סיים, ולכן הבנאי האחרון בשרשרת מדפיס ראשון.
בדקו את עצמכם
במחלקה Q הבנאי Q() מכיל this(2); ואחריו System.out.print("K");, והבנאי Q(int n) מדפיס את n + n. מה ידפיס new Q()?

4K. קודם Q(2) מסיים ומדפיס 4, ורק אז Q() ממשיך ומדפיס K.

ב-C#, איפה כותבים את ההפניה מבנאי אחד לבנאי נוסף באותה מחלקה?

בכותרת הבנאי, אחרי נקודתיים, למשל public Shipment(string city) : this(city, 1) { }.

חזרה לתוכן העניינים

בנאים לאורך שרשרת הירושה: super(...) ו-base(...)

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

  • ב-Java: super(...) כהוראה הראשונה. אם לא כתבתם אותה, המהדר מוסיף super() בלי ארגומנטים.
  • ב-C#: : base(...) בכותרת הבנאי. אם לא כתבתם, המהדר מניח : base().
  • אם למחלקת האב אין בנאי נגיש בלי פרמטרים, ה-super() המובלע נכשל, וזו שגיאת קומפילציה.

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

Java
abstract class Device {                          // abstract, yet it has a constructor
    Device() { System.out.print("[device]"); }
}

class Phone extends Device {
    Phone(String model) {                        // the compiler inserts super() here
        System.out.print("[phone " + model + "]");
    }
}

class SmartPhone extends Phone {
    SmartPhone() {
        super("X2");                             // explicit: picks Phone(String)
        System.out.print("[smart]");
    }
}

public class DeviceDemo {
    public static void main(String[] args) {
        new SmartPhone();
        System.out.println();
    }
}
פלט
[device][phone X2][smart]

שלושה דברים בדוגמה: Phone לא כותבת super(), והמהדר מוסיף אותו; SmartPhone בוחרת במפורש בבנאי Phone(String); ו-Device היא מחלקה אבסטרקטית, ובכל זאת יש לה בנאי שרץ. אי אפשר לכתוב new Device(), אבל הבנאי שלה מופעל דרך super(...) של היורשות.

אותו מבנה ב-C#, עם אותו פלט:

C#
new SmartPhone();
Console.WriteLine();

abstract class Device {
    protected Device() { Console.Write("[device]"); }
}

class Phone : Device {
    public Phone(string model) { Console.Write("[phone " + model + "]"); }   // : base() is implied
}

class SmartPhone : Phone {
    public SmartPhone() : base("X2") { Console.Write("[smart]"); }
}
פלט
[device][phone X2][smart]

וכשלאב יש רק בנאי שדורש ארגומנט, והיורשת לא בוחרת בו במפורש:

Java
class Engine {
    int power;
    Engine(int power) { this.power = power; }    // the only constructor needs an argument
}

class Truck extends Engine {
    Truck() {                                    // no super(...) written, so super() is assumed
        System.out.println("truck ready");
    }
}
פלט
Truck.java:7: error: constructor Engine in class Engine cannot be applied to given types;
    Truck() {                                    // no super(...) written, so super() is assumed
            ^
  required: int
  found: no arguments
  reason: actual and formal argument lists differ in length
1 error

בנאים לא עוברים בירושה, ולכן גם אי אפשר לדרוס אותם.

הרשאת הגישה של בנאי קובעת מי רשאי ליצור אובייקטים מהמחלקה:

הרשאת הבנאימי יכול ליצור אובייקטשימוש אופייני
privateרק המחלקה עצמהSingleton, מחלקות עזר שאין סיבה ליצור מהן מופעים, מתודות factory סטטיות
protectedמחלקות יורשות, דרך super(...) או base(...). ב-Java גם כל קוד באותה חבילה רשאי להפעיל אותו, למשל עם new (הפירוט בפרק על protected)מחלקות בסיס שנועדו להרחבה
publicכל קודרוב המחלקות
טעויות נפוצות
  • קודם מתבצע גוף הבנאי של המחלקה היורשת, ורק אחריו בנאי האב. ההפך: בנאי האב מסתיים קודם, ורק אז ממשיך גוף הבנאי של היורשת.
  • יורשת מקבלת אוטומטית את כל הבנאים של האב. בנאים אינם עוברים בירושה. יורשת מגדירה בנאים משלה ובוחרת איזה בנאי של האב להפעיל.
  • למחלקה אבסטרקטית אין בנאי, כי אי אפשר ליצור ממנה מופע. יש לה בנאים, והם רצים כחלק מבניית אובייקט של יורשת.
  • אם היורשת לא כתבה super(...), בנאי האב פשוט לא רץ. המהדר מוסיף super() מעצמו, ובנאי של האב רץ תמיד. אם אין בנאי מתאים, הקוד לא מתקמפל.
בדקו את עצמכם
Scooter יורשת מ-Vehicle, ול-Vehicle יש בנאי יחיד Vehicle(int wheels). הבנאי של Scooter לא כותב super(...). מה התוצאה?

שגיאת קומפילציה. המהדר מכניס super() בלי ארגומנטים, ואין ב-Vehicle בנאי כזה. התיקון: super(2) כהוראה הראשונה.

Leaf יורשת מ-Mid, ו-Mid יורשת מ-Root. כל בנאי מדפיס את האות הראשונה של שם המחלקה שלו. מה ידפיס new Leaf()?

RML: גוף הבנאי של Root רץ ראשון, אחריו של Mid, ובסוף של Leaf.

חזרה לתוכן העניינים

סדר האתחול, ומתודה נדרסת שנקראת מתוך בנאי האב

ב-Java, בניית אובייקט עוברת ארבעה שלבים קבועים:

  1. כל השדות, בכל רמות הירושה, מקבלים ערכי ברירת מחדל: 0 למספרים, false ל-boolean ו-null להפניות.
  2. מופעל super(...), כלומר בנאי האב רץ עד הסוף (והוא עצמו עובר את אותם שלבים מול האב שלו).
  3. רצים אתחולי השדות של המחלקה (כמו int clicks = 5) ובלוקי אתחול מופע ({ ... }), לפי הסדר שבו הם כתובים.
  4. רץ שאר גוף הבנאי.

המשמעות של שלב 3: שדה שכתוב בו = 5 מחזיק 0 כל זמן שבנאי האב פועל. הוא מקבל 5 רק אחרי שבנאי האב חזר.

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

תרחיש 6: Button.render רצה לפני שהשדות של Button קיבלו ערך
Java
class Widget {
    Widget() {
        System.out.println("Widget() starts");
        render();                                   // virtual call from a constructor
    }
    void render() { System.out.println("Widget.render"); }
}

class Button extends Widget {
    String caption = "OK";
    int clicks = 5;
    {                                               // instance initializer, runs right after the fields above
        System.out.println("init block: caption=" + caption);
    }

    Button() {
        System.out.println("Button() body: caption=" + caption + " clicks=" + clicks);
    }

    void render() { System.out.println("Button.render: caption=" + caption + " clicks=" + clicks); }
}

public class ButtonDemo {
    public static void main(String[] args) {
        new Button();
    }
}
פלט
Widget() starts
Button.render: caption=null clicks=0
init block: caption=OK
Button() body: caption=OK clicks=5
  1. new Button(): caption מתחיל כ-null ו-clicks כ-0.
  2. הבנאי של Button מתחיל ב-super() מובלע, כלומר ב-Widget(), שמדפיס Widget() starts.
  3. Widget() קורא ל-render(). האובייקט הוא Button, ולכן רצה הגרסה של Button, והיא מדפיסה caption=null clicks=0.
  4. Widget() מסתיים. עכשיו, לפי סדר הכתיבה, caption מקבל "OK", clicks מקבל 5, ובלוק האתחול מדפיס init block: caption=OK.
  5. לבסוף רץ גוף הבנאי של Button, שכבר רואה את הערכים הסופיים.

עם boolean שמאותחל ל-true הייתה המתודה רואה false, מאותה סיבה בדיוק.

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

השפות האחרות מתנהגות אחרת, ומכאן מגיעים כמה מהמסיחים בשאלות:

שפהמה רואה מתודה נדרסת שנקראת מתוך בנאי הבסיס
Javaרצה הגרסה של היורשת, ושדות היורשת עדיין בערכי ברירת מחדל (0, false, null), כי האתחולים שלהם רצים אחרי בנאי האב
C#רצה הגרסה של היורשת, אבל אתחולי השדות של היורשת כבר רצו, כי הם מתבצעים לפני הפנייה לבנאי הבסיס. חסרים רק ערכים שגוף הבנאי של היורשת מציב
C++כל עוד בנאי הבסיס רץ, הקריאה מגיעה לגרסה של מחלקת הבסיס עצמה, בלי dispatch וירטואלי לחלק שעוד לא נבנה
כלל ההתנהגות של C++ שווה זכירה דווקא כדי לא לייחס אותו ל-Java: שם, כל עוד בנאי הבסיס לא סיים, האובייקט נחשב לאובייקט של הבסיס, ולכן render() הייתה מגיעה ל-Widget.render. ב-Java אותה דוגמה מגיעה ל-Button.render, כפי שראיתם בפלט.

כך מתנהגת C# בהרצה אמיתית:

C#
new Thermo();

class Sensor {
    public Sensor() {
        Console.WriteLine("Sensor ctor");
        Report();                                   // virtual call from the base constructor
    }
    public virtual void Report() { Console.WriteLine("Sensor.Report"); }
}

class Thermo : Sensor {
    string unit = Trace("unit", "C");              // field initializer
    string zone;                                   // set only in the constructor body

    public Thermo() {
        zone = "north";
        Console.WriteLine("Thermo ctor");
    }

    static string Trace(string name, string value) {
        Console.WriteLine("initializer " + name);
        return value;
    }

    public override void Report() {
        Console.WriteLine("Thermo.Report unit=" + unit + " zone=" + (zone ?? "null"));
    }
}
פלט
initializer unit
Sensor ctor
Thermo.Report unit=C zone=null
Thermo ctor

אתחול השדה unit רץ ראשון, עוד לפני Sensor ctor, ולכן Report רואה unit=C. את zone מציב רק גוף הבנאי של Thermo, שעוד לא רץ, ולכן הוא null.

אתחול סטטי הוא סיפור נפרד. ב-Java בלוקי static { } ואתחולי שדות סטטיים רצים פעם אחת, כשהמחלקה מאותחלת בשימוש הפעיל הראשון בה, לפי סדר הכתיבה. הבנאי, לעומתם, רץ בכל new:

Java
class Gate {
    static { System.out.println("static block of Gate"); }   // class initialization, once

    Gate() { System.out.println("Gate() constructor"); }      // every new

    static int opened = count("opened");
    static int count(String what) { System.out.println("static field " + what); return 0; }
}

public class GateDemo {
    public static void main(String[] args) {
        // class initialization has not happened yet
        System.out.println("main begins");
        new Gate();
        new Gate();
    }
}
פלט
main begins
static block of Gate
static field opened
Gate() constructor
Gate() constructor

ב-C# יש בנאי סטטי, static Gate() { }, בלי הרשאת גישה ובלי פרמטרים. הוא מופעל אוטומטית, לכל היותר פעם אחת, לפני יצירת המופע הראשון או לפני הגישה הראשונה לחבר סטטי:

C#
Console.WriteLine("Main begins");
new Gate();
new Gate();

class Gate {
    static Gate() { Console.WriteLine("static ctor of Gate"); }   // no modifier, no parameters
    public Gate() { Console.WriteLine("Gate ctor"); }
}
פלט
Main begins
static ctor of Gate
Gate ctor
Gate ctor
טעויות נפוצות
  • ב-Java שדות היורשת מקבלים את הערכים שלהם עוד לפני שבנאי האב מתחיל. זה מתאר את C#. ב-Java אתחולי השדות של היורשת רצים רק אחרי ש-super(...) הסתיים.
  • ב-Java, קריאה מתוך בנאי מגיעה תמיד לגרסה של המחלקה שבנייתה מתבצעת עכשיו. זה הכלל של C++. Java בוחרת את הגרסה לפי הטיפוס האמיתי של האובייקט, גם בתוך בנאי.
  • קריאה מבנאי למתודה שאפשר לדרוס היא שגיאת קומפילציה. הקוד מתקמפל ורץ. ההימנעות מכך היא המלצת עיצוב, לא כלל של השפה.
  • בלוק static { } רץ מחדש בכל new. הוא רץ פעם אחת, באתחול המחלקה. בכל new רצים הבנאי, אתחולי שדות המופע ובלוקי אתחול המופע.
בדקו את עצמכם
ב-Java, הבנאי של Alarm קורא ל-arm(). DoorAlarm יורשת מ-Alarm, מגדירה boolean armed = true ודורסת את arm() כך שתדפיס את armed. מה יודפס בזמן new DoorAlarm()?

false. arm() של DoorAlarm רצה מתוך הבנאי של Alarm, לפני שאתחול השדה הציב בו true, ולכן היא רואה את ערך ברירת המחדל.

אותו מבנה ב-C#, כש-armed מקבל true באתחול השדה (bool armed = true;). מה יודפס?

True. ב-C# אתחולי השדות של היורשת רצים לפני בנאי הבסיס, ולכן המתודה הנדרסת כבר רואה את הערך. אילו true היה מוצב בגוף הבנאי של DoorAlarm, היה מודפס False.

חזרה לתוכן העניינים

protected: הרשאה שנבנתה בשביל היורשות

protected ב-Java: מה נפתח ולמי

לכל חבר במחלקה, בין אם זה שדה, מתודה או בנאי, מצמידים הרשאת גישה (Access Modifier). ההרשאה עונה על שאלה אחת: קוד שכתוב במקום מסוים, האם מותר לו לגעת בחבר הזה.

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

ב-Java, שלושה סוגים של קוד רואים חבר protected:

  • הקוד של המחלקה שבה הוא הוגדר.
  • כל מחלקה ששייכת לאותה חבילה (package), יורשת או לא יורשת, אין הבדל.
  • מחלקות יורשות שנמצאות בחבילות אחרות.

דרך נוחה לזכור: קחו את ההרשאה שמקבלים כשלא כותבים שום מילת מפתח (package-private), שפותחת את החבר לכל החבילה, והוסיפו לה את היורשות שמחוץ לחבילה. זו protected של Java.

הרשאה ב-Javaבתוך המחלקהמחלקה אחרת בחבילהיורשת מחבילה זרהכל קוד אחר
privateכןלאלאלא
בלי מילת מפתח (package-private)כןכןלאלא
protectedכןכןכןלא
publicכןכןכןכן

הבהרה ראשונה שחוזרת בשאלות: אין ל-protected גרסה של קריאה בלבד. קוד שמורשה לגשת יכול גם לשנות את הערך.

הבהרה שנייה: import לא פותח ולא סוגר שום הרשאה. הוא רק חוסך לכתוב את השם המלא של המחלקה, ומחלקות שחולקות חבילה לא צריכות אותו בכלל.

Java
// file: library/Loan.java
package library;

public class Loan {
    protected int daysLeft = 14;
}

// file: library/Reminder.java
package library;

class Reminder {                         // same package, does not extend Loan
    int extend(Loan loan) {
        loan.daysLeft += 7;              // write access: compiles
        return loan.daysLeft;            // read access: compiles
    }

    public static void main(String[] args) {
        System.out.println(new Reminder().extend(new Loan()));
    }
}
פלט
21

המחלקה Reminder לא יורשת מ-Loan, ובכל זאת היא גם קוראת את daysLeft וגם מגדילה אותו מ-14 ל-21, בלי אף שורת import. הסיבה היחידה: שתיהן יושבות בחבילה library.

ההרשאות של מחלקה שלמה מצומצמות יותר. מחלקה שאינה מקוננת בתוך מחלקה אחרת (top-level) יכולה להיות public או בלי מילת מפתח, וזהו. את protected ואת private שומרים למחלקות מקוננות.

Java
protected class Ticket { }
פלט
Ticket.java:1: error: modifier protected not allowed here
protected class Ticket { }
          ^
1 error

כלל נוסף נוגע לדריסה: מתודה דורסת לא רשאית להיות פחות נגישה מהמתודה שהיא דורסת. מתודת protected אפשר לדרוס כ-protected או להרחיב ל-public, אבל לא להוריד להרשאת חבילה או ל-private.

Java
class Printer {
    protected void warmUp() { }
}

class LaserPrinter extends Printer {
    void warmUp() { }                    // package-private is narrower than protected
}
פלט
LaserPrinter.java:6: error: warmUp() in LaserPrinter cannot override warmUp() in Printer
    void warmUp() { }                    // package-private is narrower than protected
         ^
  attempting to assign weaker access privileges; was protected
1 error
טעויות נפוצות
  • ב-Java רק מחלקה שיורשת יכולה לגשת לחבר protected. גם מחלקה שאינה יורשת ניגשת אליו, בתנאי שהיא באותה חבילה. ההרשאה כוללת את כל החבילה.
  • protected ב-Java פתוחה למחלקה ולחבילה שלה, וננעלת בפני יורשת שיושבת בחבילה אחרת. יורשת מחבילה זרה היא בדיוק התוספת ש-protected נותנת מעבר להרשאת החבילה. יש לה גישה, עם הגבלה על סוג ההפניה שנפרט בתת-הפרק הבא.
  • מחלקה מאותה חבילה שאינה יורשת יכולה רק לקרוא את הערך, לא לשנות אותו. ב-Java אין הרשאה חלקית כזו. כמו בדוגמה של Reminder, מי שמורשה לגשת גם כותב.
  • בלי import של המחלקה המגדירה, הגישה לחבר protected נחסמת. import משפיע רק על השם שכותבים בקוד, לא על מה שמותר לגשת אליו.
  • אפשר להצהיר על המחלקה הראשית של קובץ כ-protected, והיא פשוט תהיה זמינה ליורשות. המהדר דוחה את זה עם modifier protected not allowed here. למחלקה ברמה העליונה מותרות רק public או היעדר מילת מפתח.
בדקו את עצמכם
ב-Java, המחלקה Booking מגדירה protected double price. המחלקה Cashier נמצאת באותה חבילה ואין בינה לבין Booking קשר של ירושה. האם Cashier רשאית להוריד את המחיר של הזמנה?

כן. בתוך החבילה protected מתנהגת כמו הרשאת חבילה מלאה, כולל כתיבה.

סדרו את ארבע ההרשאות של Java מזו שפותחת הכי מעט לזו שפותחת הכי הרבה.

private, אחריה הרשאת החבילה (בלי מילת מפתח), אחריה protected, ובסוף public.

דורסים במחלקה יורשת מתודה שהוגדרה protected, ושוכחים לכתוב לפניה הרשאה. מה יקרה?

שגיאת קומפילציה. בלי מילת מפתח המתודה מקבלת הרשאת חבילה, שהיא צרה יותר מ-protected, וב-Java אסור לצמצם נראות בדריסה.

חזרה לתוכן העניינים

יורשת מחבילה אחרת: הגבלת ההפניה ובנאי protected

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

בפועל, this.volume, וגם other.volume כש-other מוצהר כ-LiveTrack, עוברים. לעומתם t.volume כש-t מוצהר כ-Track נחסם.

ההגבלה נוגעת לחברי מופע בלבד. את Track.created, שהוא protected static, היורשת קוראת דרך שם המחלקה בלי שום תנאי על ההפניה.

ומה לגבי בנאי protected? מחבילה אחרת יש רק שתי דרכים להפעיל אותו: קריאה ל-super(...) מתוך בנאי של יורשת, או יצירה של מחלקה אנונימית בכתיב new Track() { }. ביטוי new רגיל נחסם, גם כשהוא כתוב בתוך היורשת עצמה.

Java
// file: media/Track.java
package media;

public class Track {
    protected int volume;
    protected static int created;
    protected Track() { created++; }
}

// file: studio/LiveTrack.java
package studio;

import media.Track;

public class LiveTrack extends Track {
    public LiveTrack() { super(); }                       // OK: via super()
    void louder() { this.volume += 5; }                   // OK: own object
    void match(LiveTrack other) { volume = other.volume; } // OK: reference of own type
    int count() { return Track.created; }                 // OK: protected static
    void copy(Track t) { volume = t.volume; }             // error: parent-type reference
    Track fresh() { return new Track(); }                 // error: plain new
    Track quick() { return new Track() { }; }             // OK: anonymous subclass
}
פלט
studio\LiveTrack.java:10: error: volume has protected access in Track
    void copy(Track t) { volume = t.volume; }             // error: parent-type reference
                                   ^
studio\LiveTrack.java:11: error: Track() has protected access in Track
    Track fresh() { return new Track(); }                 // error: plain new
                           ^
2 errors

השגיאה הראשונה נובעת מגישה דרך הפניה מטיפוס האב, והשנייה מ-new רגיל. כל שאר השורות מתקמפלות, כולל המחלקה האנונימית בשורה האחרונה והגישה הסטטית.

מה המשמעות לתכנון? בנאי protected מונע ממי שמבחוץ ליצור את המחלקה ישירות, ועדיין מאפשר לרשת ממנה ולבנות אותה דרך היורשת. לכן מחלקות בסיס, ובעיקר מחלקות אבסטרקטיות, מקבלות לעתים קרובות בנאי protected.

תרחיש 7: תנור עם בנאי protected ושלושה ניסיונות מחבילה זרה

בחבילה kitchen מוגדרת המחלקה Oven, והבנאי שלה protected. בחבילה bakery כותבים שלושה קטעי קוד:

  1. PizzaOven extends Oven, ובבנאי שלה הקריאה super(). מתקמפל: זו בדיוק הדרך שבה יורשת מחבילה אחרת מפעילה בנאי protected.
  2. מתודה בתוך PizzaOven מחזירה new Oven(). לא מתקמפל: גם יורשת, כשהיא בחבילה אחרת, לא יוצרת את האב ב-new ישיר.
  3. המחלקה Menu, שאינה יורשת, כותבת new Oven(). לא מתקמפל, וזה נכון בכל חבילה חוץ מ-kitchen.

עכשיו העבירו את Menu לחבילה kitchen. אותה שורה בדיוק מתקמפלת, כי בתוך החבילה של המחלקה protected פתוחה לכל קוד.

טעויות נפוצות
  • יורשת שנמצאת בחבילה אחרת רשאית לכתוב new לאב שהבנאי שלו protected, הרי היא יורשת. מחבילה זרה הבנאי נגיש רק דרך super(...) או דרך מחלקה אנונימית. new ישיר נכשל עם has protected access.
  • קוד שאינו יורש יכול להפעיל בנאי protected מכל מקום בתוכנית. רק מתוך החבילה של המחלקה. בכל חבילה אחרת, קוד שאינו יורש לא יוצר אותה.
  • בנאי protected נעול לגמרי בפני יורשות מחבילה אחרת. הן מפעילות אותו כרגיל דרך super() בבנאי שלהן.
  • יורשת מחבילה זרה ניגשת לשדה protected של כל אובייקט, כל עוד ההפניה מטיפוס האב. דווקא הפניה מטיפוס האב נחסמת. הגישה עוברת רק דרך הפניה מהטיפוס של היורשת או מתת-טיפוס שלה.
בדקו את עצמכם
בחבילה bank המחלקה Wallet מגדירה protected long coins. בחבילה family המחלקה KidsWallet יורשת ממנה ומכילה שתי מתודות: אחת מחזירה k.coins עבור פרמטר KidsWallet k, והשנייה מחזירה w.coins עבור פרמטר Wallet w. איזו מהן מתקמפלת?

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

אילו Wallet הייתה מגדירה גם protected static int issued, האם KidsWallet הייתה יכולה לקרוא Wallet.issued?

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

חזרה לתוכן העניינים

protected ב-C# ושאר ההרשאות של השפה

ב-C# המשמעות צרה יותר: חבר protected זמין למחלקה שהגדירה אותו ולמחלקות שנגזרות ממנה, ולאף אחד אחר. מחלקה נגזרת היא בדיוק מה שבחלקי ה-Java קראנו מחלקה יורשת.

אין כאן מקבילה לחבילה של Java שנכללת בהרשאה. assembly הוא מה שנוצר כשבונים פרויקט ב-.NET: קובץ DLL או EXE, היחידה שמפיצים ושנטענת בזמן ריצה. מחלקה שיושבת באותו assembly אבל אינה נגזרת לא רואה את החבר.

לכן ההבדל מול public פשוט: public פתוחה לכל קוד בכל מקום, ו-protected רק למחלקה ולשרשרת היורשות שלה.

הרשאה ב-C#מי רשאי לגשת
privateרק המחלקה עצמה. זו גם ההרשאה שחבר מחלקה מקבל כשלא כותבים כלום
protectedהמחלקה ומחלקות נגזרות, בכל assembly שהן
internalכל קוד שנמצא באותו assembly
protected internalנגזרות מכל מקום, או כל קוד באותו assembly: האיחוד של השתיים
private protectedנגזרות בלבד, ורק כשהן באותו assembly: החיתוך של השתיים (נוספה ב-C# 7.2)
publicכל קוד

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

C#
using System;

class Drone
{
    protected int altitude;
    protected Drone() { }
    protected virtual void Report() { }
}

class RaceDrone : Drone
{
    public RaceDrone() : base() { }                          // OK: protected constructor via base()
    void Climb(RaceDrone peer) { altitude = 10; peer.altitude = 20; } // OK
    void Push(Drone other) { other.altitude = 5; }           // error CS1540
}

class Hangar                                                 // same assembly, not derived
{
    static void Main()
    {
        Drone a = new RaceDrone();                           // OK: RaceDrone() is public
        Drone b = new Drone();                               // error CS0122
        a.altitude = 1;                                      // error CS0122
        a.Report();                                          // error CS0122
    }
}
פלט
Program.cs(14,36): error CS1540: Cannot access protected member 'Drone.altitude' via a qualifier of type 'Drone'; the qualifier must be of type 'RaceDrone' (or derived from it)
Program.cs(22,23): error CS0122: 'Drone.Drone()' is inaccessible due to its protection level
Program.cs(23,11): error CS0122: 'Drone.altitude' is inaccessible due to its protection level
Program.cs(24,11): error CS0122: 'Drone.Report()' is inaccessible due to its protection level

השורה new RaceDrone() עוברת: הבנאי של RaceDrone הוא public, ומשם הוא מפעיל את בנאי ה-protected של Drone דרך base(). לעומתה new Drone() נכשלת אף ש-Hangar נמצאת באותו assembly, כי ב-C# ההרשאה protected לא מתרחבת ל-assembly.

צירוף שכדאי להכיר הוא protected virtual. המחלקה והנגזרות שלה יכולות לקרוא למתודה, נגזרות יכולות לדרוס אותה עם override, וקוד שמחוץ להיררכיית הירושה לא יכול לקרוא לה בכלל. זה מתאים במיוחד ל-hook שמחלקת הבסיס מפעילה בעצמה:

C#
using System;

class Drone
{
    public void Fly() { Report(); }                 // the base class calls its own hook
    protected virtual void Report() { Console.WriteLine("Drone: generic report"); }
}

class RaceDrone : Drone
{
    protected override void Report() { Console.WriteLine("RaceDrone: lap time 41s"); }
}

class Program
{
    static void Main()
    {
        Drone d = new RaceDrone();
        d.Fly();
        // d.Report();  would not compile here: Program is outside the hierarchy
    }
}
פלט
RaceDrone: lap time 41s

בדריסה ב-C# ההרשאה חייבת להישאר בדיוק כפי שהייתה. דריסה של protected virtual נכתבת protected override, וכל שינוי, גם הרחבה ל-public, נדחה:

C#
class Drone
{
    protected virtual void Report() { }
}

class RaceDrone : Drone
{
    public override void Report() { }    // access widened while overriding
}

class Program { static void Main() { } }
פלט
Program.cs(8,26): error CS0507: 'RaceDrone.Report()': cannot change access modifiers when overriding 'protected' inherited member 'Drone.Report()'
יוצא דופן אחד: כשדורסים חבר protected internal שהוגדר ב-assembly אחר, הדריסה נכתבת protected בלבד.
תרחיש 8: מחלקת בדיקות שנגזרת מהמחלקה שהיא בודקת

למחלקה PriceCalculator יש מתודה protected decimal ApplyDiscount(decimal total). כדי לבדוק אותה ישירות, כותבים מחלקה PriceCalculatorTests : PriceCalculator.

  • בתוך PriceCalculatorTests הקריאה ApplyDiscount(100) עובדת, וכך גם קריאה דרך משתנה מטיפוס PriceCalculatorTests.
  • המחלקה CheckoutService, באותו פרויקט אבל בלי ירושה, לא יכולה לקרוא ל-ApplyDiscount (CS0122).
  • גם מתוך מחלקת הבדיקות, קריאה דרך משתנה מטיפוס PriceCalculator שמחזיק מופע אחר נכשלת עם CS1540.

כדי לפתוח את המתודה לכל הפרויקט צריך internal או protected internal.

טעויות נפוצות
  • ב-C#, protected כבר כוללת את כל הקוד של ה-assembly, בדיוק כמו internal. את השילוב הזה נותנת protected internal. protected לבדה פתוחה רק לנגזרות.
  • חבר protected נגיש אך ורק בתוך המחלקה שהגדירה אותו. זה תיאור של private. protected מוסיפה את כל המחלקות הנגזרות.
  • protected מאפשרת גישה לפונקציות שהוכרזו friend. friend שייך ל-C++ ולא קיים ב-C#. ל-protected של C# אין שום קשר אליו.
  • נגזרת רשאית לקרוא שדה protected, אבל רק מחלקת הבסיס משנה אותו. הגישה של הנגזרת מלאה, כמו ב-Climb שכותבת לשדה ישירות.
  • נגזרת צריכה getter ציבורי כדי להגיע לשדה protected. היא ניגשת אליו בשמו, בלי שום מתווך.
  • public נגישה דרך שם המחלקה, ו-protected דרך מופע. הרשאה ו-static הן שתי שאלות נפרדות. כל הרשאה יכולה לחול על חבר סטטי או על חבר מופע.
  • בנאי protected מונע יצירה של אובייקט בכל דרך שהיא. נגזרת מפעילה אותו דרך base(), ולכן new RaceDrone() עובד.
  • כשדורסים protected virtual חובה לכתוב public override. ב-C# ההרשאה בדריסה זהה למקור, כלומר protected override. public override מסתיימת ב-CS0507.
בדקו את עצמכם
ב-C#, ל-Mailer יש protected void Flush(). המחלקה Scheduler, באותו assembly ובלי ירושה, מחזיקה משתנה mailer וכותבת mailer.Flush(). מה התוצאה?

הקוד לא מתקמפל, שגיאה CS0122. protected ב-C# לא נותנת דבר לשאר ה-assembly.

צריך חבר ב-C# שנגיש גם לכל מחלקה נגזרת בכל assembly וגם לכל קוד באותו assembly. איזו הרשאה מתאימה, ואיזו הרשאה נותנת דווקא את החיתוך של שני התנאים?

protected internal היא האיחוד. private protected היא החיתוך: רק נגזרות שנמצאות באותו assembly.

חזרה לתוכן העניינים

שדה protected, או שדה private עם מתודות protected

כששדה מוגדר protected, כל מחלקה יורשת רואה אותו, וב-Java גם כל מחלקה שחולקת את החבילה. פרטי המימוש של המחלקה הופכים כך לחלק מההתחייבות שלה כלפי כל המחלקות האלה.

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

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

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

Java
abstract class Thermostat {
    private double targetCelsius = 21;          // subclasses cannot touch it directly

    protected double getTarget() { return targetCelsius; }

    protected void setTarget(double c) {        // the one place that guards the value
        if (c < 5 || c > 35) throw new IllegalArgumentException("out of range: " + c);
        targetCelsius = c;
    }
}

class NightMode extends Thermostat {
    void apply() { setTarget(getTarget() - 3); }
    void broken() { setTarget(-40); }
}

public class HomeDemo {
    public static void main(String[] args) {
        NightMode n = new NightMode();
        n.apply();
        System.out.println(n.getTarget());     // same package, so visible here
        n.broken();
    }
}
פלט
18.0
Exception in thread "main" java.lang.IllegalArgumentException: out of range: -40.0
	at Thermostat.setTarget(HomeDemo.java:7)
	at NightMode.broken(HomeDemo.java:14)
	at HomeDemo.main(HomeDemo.java:22)

NightMode מורידה את הטמפרטורה ל-18 רק דרך setTarget, וכשהיא מנסה להציב ערך לא סביר היא מקבלת חריגה במקום לשבש את האובייקט. מחר Thermostat תוכל לשמור את היעד בפרנהייט או כמספר שלם, ואף יורשת לא תצטרך להשתנות.

איפה protected כן במקומה? בעיקר במתודות hook שמחלקת הבסיס מפעילה והיורשות דורסות, ובבנאים של מחלקות בסיס אבסטרקטיות.

טעויות נפוצות
  • הקומפיילר לא אוכף protected על שדות, ולכן הם למעשה פתוחים לכולם. ההרשאה נאכפת על שדות בדיוק כמו על מתודות. הבעיה איננה דליפה לכל התוכנית, אלא התלות של היורשות במימוש.
  • שדות protected לא עוברים בירושה, וכל יורשת חייבת להגדיר אותם מחדש. הם עוברים בירושה, ודווקא בגלל זה היורשות נקשרות אליהם.
  • שדה protected נשמר פעם אחת ומשותף לכל האובייקטים. שיתוף כזה הוא תכונה של static. protected קובעת רק מי ניגש.
  • כדי לצמצם את החשיפה, השדות נשארים protected ולצדם נכתבות מתודות get ו-set פתוחות לכולם. כך החשיפה דווקא גדלה: מעכשיו גם קוד שאין לו שום קשר להיררכיה קורא ומשנה את הערך.
  • הערה בקוד שמבקשת מהיורשות לא לגעת בשדה פותרת את הבעיה. המהדר לא קורא הערות, ושום דבר לא מונע מיורשת להתעלם ממנה.
  • final ב-Java או readonly ב-C# על כל השדות מספיקים. הם מונעים שינוי אחרי האתחול, אבל השדה עדיין חשוף והיורשות עדיין כתובות מול המימוש שלו.
בדקו את עצמכם
המחלקה Seat חושפת protected String seatCode עם ערכים כמו B12, ושתים עשרה יורשות מפרקות את המחרוזת בעצמן. עכשיו רוצים לשמור את השורה ואת המספר בשני שדות נפרדים. מה יקרה, ואיזה עיצוב היה חוסך את זה?

כל שתים עשרה היורשות יישברו, כי הן תלויות במבנה השדה. אילו השדה היה private ומחלקת הבסיס הייתה חושפת מתודות protected כמו row() ו-number(), השינוי היה נשאר בתוך Seat.

למה setTarget בדוגמה מוגדרת protected ולא public?

כדי שרק היורשות (וב-Java גם הקוד שבחבילה) יוכלו לשנות את היעד, ותמיד דרך הבדיקה. public הייתה פותחת את השינוי לכל התוכנית.

חזרה לתוכן העניינים

Interface: ממשק כחוזה בין חלקי הקוד

ממשק: חוזה בלי מימוש

ממשק (Interface) הוא טיפוס הפניה שכל תפקידו לנסח חוזה: אילו מתודות יהיו לכל מחלקה שתצהיר שהיא מממשת אותו. מחלקה שחותמת על החוזה מתחייבת לספק את כולן.

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

Java
interface Billable {
    double monthlyFee();                        // implicitly public abstract
}

class StreamingPlan implements Billable {
    private final int screens;
    StreamingPlan(int screens) { this.screens = screens; }
    public double monthlyFee() { return 9.5 + 3 * screens; }   // must be public
}

class GymMembership implements Billable {
    private final boolean withPool;
    GymMembership(boolean withPool) { this.withPool = withPool; }
    public double monthlyFee() { return withPool ? 60 : 45; }
}

public class Billing {
    public static void main(String[] args) {
        Billable[] items = { new StreamingPlan(2), new GymMembership(true) };
        double sum = 0;
        for (Billable b : items) sum += b.monthlyFee();    // the caller knows only the contract
        System.out.println("total: " + sum);
    }
}
פלט
total: 75.5

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

הכללים של Java:

  • מתודה שמוצהרת בממשק בלי גוף היא public abstract, גם אם לא כתבתם את המילים האלה.
  • שדה בממשק הוא תמיד public static final: קבוע אחד ששייך לממשק. לממשק אין שדות מופע, ולכן אין לו מצב של אובייקט.
  • לממשק אין בנאים, ולא יוצרים ממנו מופע עם new.
  • אפשר לממש ממשק במחלקה אנונימית. ממשק שיש בו מתודה מופשטת אחת בדיוק נקרא functional interface, ואותו אפשר לממש גם בביטוי lambda.
  • המתודה המממשת חייבת להיות public. השמטת ההרשאה הופכת אותה להרשאת חבילה, וזה צמצום שהמהדר לא מתיר.
Java
interface Billable { double monthlyFee(); }

class Trial implements Billable {
    double monthlyFee() { return 0; }           // no modifier: package-private
}
פלט
Trial.java:4: error: monthlyFee() in Trial cannot implement monthlyFee() in Billable
    double monthlyFee() { return 0; }           // no modifier: package-private
           ^
  attempting to assign weaker access privileges; was public
1 error
Java
interface Discount {
    int MAX_PERCENT = 90;                       // implicitly public static final
    double apply(double price);                 // the only abstract method
}

public class Coupons {
    public static void main(String[] args) {
        Discount half = price -> price / 2;     // lambda: Discount is a functional interface
        Discount minusTen = new Discount() {    // anonymous class
            public double apply(double price) { return price - 10; }
        };
        System.out.println(half.apply(80) + " " + minusTen.apply(80));
        System.out.println(Discount.MAX_PERCENT);
    }
}
פלט
40.0 70.0
90
Java
interface Discount {
    int MAX_PERCENT = 90;
    double apply(double price);
}

public class Checkout {
    public static void main(String[] args) {
        Discount.MAX_PERCENT = 95;              // trying to change an interface field
        Discount d = new Discount();            // trying to instantiate an interface
    }
}
פלט
Checkout.java:8: error: cannot assign a value to final variable MAX_PERCENT
        Discount.MAX_PERCENT = 95;              // trying to change an interface field
                ^
Checkout.java:9: error: Discount is abstract; cannot be instantiated
        Discount d = new Discount();            // trying to instantiate an interface
                     ^
2 errors

ב-C# הכתיב שונה מעט: interface IBillable { decimal MonthlyFee(); }, והמחלקה מצהירה class GymMembership : IBillable. האות I בתחילת השם היא מוסכמת שמות של C#, לא דרישה של השפה.

ב-C# כל חבר של ממשק הוא public אם לא כתבתם אחרת, וגם כאן אין לממשק שדות מופע. גם struct יכול לממש ממשק, אבל כשממירים אותו לטיפוס הממשק הערך נארז בתוך אובייקט (boxing), כלומר נוצר עותק:

C#
using System;

interface IBillable { decimal MonthlyFee(); }

struct Voucher : IBillable                         // a struct can implement an interface too
{
    public decimal Amount;
    public decimal MonthlyFee() => Amount;
}

class Program
{
    static void Main()
    {
        Voucher v = new Voucher { Amount = 20 };
        IBillable boxed = v;                       // boxing: a copy goes into a heap object
        v.Amount = 50;                             // changes the original struct only
        Console.WriteLine(v.MonthlyFee() + " " + boxed.MonthlyFee());
    }
}
פלט
50 20

יש גם ממשקים שאין בהם אף מתודה. הם נקראים marker interface, ותפקידם רק לסמן שלמחלקה יש יכולת מסוימת. הדוגמאות המוכרות ב-Java הן Serializable ו-Cloneable.

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

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

טעויות נפוצות
  • ממשק הוא בעצם מחלקה אבסטרקטית שיש לה שדות מופע ובנאי. לממשק אין שדות מופע ואין בנאים. בדיוק בזה הוא שונה ממחלקה אבסטרקטית.
  • אפשר לכתוב new על ממשק ולקבל אובייקט. המהדר עונה is abstract; cannot be instantiated. יוצרים מופע של מחלקה מממשת, או מחלקה אנונימית, או lambda.
  • ממשק הוא מחלקה שכל המתודות שלה static. ממשק מגדיר מתודות מופע שהמחלקות המממשות מספקות. מתודות static בממשק הן תוספת מאוחרת ולא העיקר.
  • כל מחלקה מממשת מקבלת עותק משלה של השדות שבממשק. שדה בממשק הוא public static final: עותק יחיד וקבוע ששייך לממשק עצמו.
  • בעזרת ממשק מחליטים איזה חלק מהמצב הפנימי של מחלקה ייחשף לקוד אחר. הנראות של שדות המחלקה נקבעת בהרשאות הגישה שלה. הממשק מדבר רק על המתודות שהיא מבטיחה.
  • מתודות של ממשק לא יכולות להיות public. להפך: הן public כברירת מחדל, וב-Java המימוש שלהן חייב להיות public.
בדקו את עצמכם
בממשק Limits ב-Java כתוב int MAX_USERS = 500;. מחלקה שמממשת אותו מנסה להציב MAX_USERS = 600 בבנאי שלה. מה יקרה, ולמה?

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

איזה תנאי צריך להתקיים בממשק כדי שאפשר יהיה לממש אותו ב-Java בביטוי lambda?

שתהיה בו מתודה מופשטת אחת בדיוק (functional interface).

חזרה לתוכן העניינים

מחלקה אחת שמממשת כמה ממשקים

גם ב-Java וגם ב-C# מחלקה יורשת ממחלקה אחת לכל היותר. ממשקים, לעומת זאת, היא יכולה לממש בלי הגבלה על המספר.

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

החריג הוא מתודות default (מ-Java 8 ומ-C# 8): את הגוף שלהן האובייקט מקבל מהממשק, וכך קוד מוכן יכול להגיע גם מכמה ממשקים. ב-C# המחלקה לא יורשת חבר כזה, ומגיעים אליו רק דרך הפניה מטיפוס הממשק.

בתת-הפרק הבא תראו איך זה עובד ומה קורה כששני ממשקים מביאים את אותה מתודה.

שני צעדים:

  1. בכותרת המחלקה, אחרי implements, מונים את כל הממשקים ומפרידים ביניהם בפסיקים. אם יש גם מחלקת אב, extends בא לפני.
  2. בגוף המחלקה כותבים מימוש public לכל מתודה מופשטת של כל אחד מהממשקים.
Java
interface Trackable    { String location(); }
interface Rechargeable { int batteryPercent(); }
interface Wearable extends Trackable, Rechargeable { }   // an interface may extend several

class RentalItem {
    protected final String code;
    RentalItem(String code) { this.code = code; }
}

class Scooter extends RentalItem implements Trackable, Rechargeable {
    Scooter(String code) { super(code); }
    public String location() { return "Dock 4"; }
    public int batteryPercent() { return 63; }
}

public class Fleet {
    public static void main(String[] args) {
        Scooter s = new Scooter("SC-17");
        Trackable t = s;                       // the same object seen as three types
        Rechargeable r = s;
        System.out.println(s.code + " at " + t.location() + ", " + r.batteryPercent() + "%");
    }
}
פלט
SC-17 at Dock 4, 63%

ב-C# הכול נכנס אחרי נקודתיים: class Scooter : RentalItem, ITrackable, IRechargeable. אם יש מחלקת בסיס, היא חייבת להופיע ראשונה ברשימה.

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

Java
interface Trackable    { String location(); }
interface Rechargeable { int batteryPercent(); }

class Scooter implements Trackable, Rechargeable {
    public String location() { return "Dock 4"; }
    // batteryPercent() is missing
}
פלט
Fleet.java:4: error: Scooter is not abstract and does not override abstract method batteryPercent() in Rechargeable
class Scooter implements Trackable, Rechargeable {
^
1 error

ממשק יכול גם להרחיב כמה ממשקים אחרים, כמו interface Wearable extends Trackable, Rechargeable בדוגמה הראשונה. מחלקה שתממש את Wearable תצטרך לספק את המתודות של שניהם.

טעויות נפוצות
  • כדי לממש שלושה ממשקים יורשים משלוש מחלקות בסיס, אחת לכל ממשק. Java ו-C# מתירות מחלקת אב אחת בלבד. את כל הממשקים מונים באותה כותרת.
  • מתודה שלא נכתבה מקבלת מהמהדר גוף ריק. המהדר עוצר עם does not override abstract method, אלא אם המחלקה מוצהרת abstract.
  • מחזיקים בתוך המחלקה מופע של כל ממשק כשדה, וכך היא מממשת את כולם. אי אפשר ליצור מופע של ממשק, וגם שדה כזה לא היה הופך את המחלקה לטיפוס של הממשק.
  • מחלקה מוגבלת לממשק אחד, בדיוק כמו שהיא מוגבלת למחלקת אב אחת. ההגבלה חלה רק על מחלקות. מספר הממשקים חופשי.
בדקו את עצמכם
המחלקה Camera צריכה להיות גם Zoomable וגם Recordable, ושניהם ממשקים ב-Java. היא כבר יורשת מ-Device. איך תיראה הכותרת שלה, ומה חייב להופיע בגוף?

class Camera extends Device implements Zoomable, Recordable, ובגוף מימוש public לכל מתודה מופשטת של שני הממשקים (אחרת המחלקה חייבת להיות abstract).

חזרה לתוכן העניינים

מתודות עם גוף בתוך ממשק, והתנגשויות ביניהן

עד Java 7 ממשק הכיל רק מתודות בלי גוף. Java 8 שינתה את זה בשתי תוספות: מתודות default, שיש להן גוף ושהמחלקה המממשת מקבלת כמו שהן או דורסת, ומתודות static. ב-Java 9 נוספו גם מתודות private בתוך ממשק.

Java
interface Greeter {
    String name();                                        // abstract
    default String greet() { return "Hello, " + name(); } // Java 8: body inside the interface
    static Greeter of(String n) { return () -> n; }      // Java 8: static helper
}

class Receptionist implements Greeter {
    public String name() { return "Dana"; }               // greet() is inherited as is
}

class Butler implements Greeter {
    public String name() { return "Alfred"; }
    public String greet() { return "Good evening. I am " + name(); }   // overrides the default
}

public class Lobby {
    public static void main(String[] args) {
        System.out.println(new Receptionist().greet());
        System.out.println(new Butler().greet());
        System.out.println(Greeter.of("Noa").greet());   // static: called on the interface name
    }
}
פלט
Hello, Dana
Good evening. I am Alfred
Hello, Noa

מתודה static של ממשק לא עוברת בירושה למחלקות המממשות. קוראים לה רק דרך שם הממשק, ודרך שם המחלקה היא פשוט לא קיימת:

Java
interface Greeter {
    String name();
    static Greeter of(String n) { return () -> n; }
}

class Receptionist implements Greeter {
    public String name() { return "Dana"; }
}

public class Lobby {
    public static void main(String[] args) {
        Greeter g = Receptionist.of("Noa");               // static interface methods are not inherited
    }
}
פלט
Lobby.java:12: error: cannot find symbol
        Greeter g = Receptionist.of("Noa");               // static interface methods are not inherited
                                ^
  symbol:   method of(String)
  location: class Receptionist
1 error

ב-C# הרעיון נקרא default interface members, והוא קיים מ-C# 8 ו-.NET Core 3.0. הבדל חשוב מ-Java: המחלקה לא יורשת את החבר הזה, ולכן קוראים לו רק דרך הפניה שהטיפוס שלה הוא הממשק.

C#
using System;

interface IGreeter
{
    string Name { get; }
    string Greet() => "Hello, " + Name;          // C# 8 default interface member
}

class Kiosk : IGreeter
{
    public string Name => "Kiosk 3";
}

class Program
{
    static void Main()
    {
        IGreeter g = new Kiosk();
        Console.WriteLine(g.Greet());              // OK: through the interface type
        Kiosk k = new Kiosk();
        Console.WriteLine(k.Greet());              // error: the class does not inherit it
    }
}
פלט
Program.cs(21,29): error CS1061: 'Kiosk' does not contain a definition for 'Greet' and no accessible extension method 'Greet' accepting a first argument of type 'Kiosk' could be found (are you missing a using directive or an assembly reference?)

כשמוחקים את שתי השורות האחרונות של Main, התוכנית מתקמפלת ומדפיסה Hello, Kiosk 3: הקריאה דרך IGreeter עובדת, ורק הקריאה דרך Kiosk נכשלה.

מה קורה כשמחלקה מקבלת שתי מתודות default עם אותה חתימה? Java מכריעה לפי סדר קבוע:

  1. מתודה שהמחלקה עצמה מגדירה, או שהיא יורשת ממחלקת אב, גוברת על כל default של ממשק.
  2. אם ממשק אחד מרחיב את השני ודורס את ה-default שלו, הגרסה של הממשק הספציפי יותר מנצחת.
  3. אם שני ממשקים שאין ביניהם קשר מביאים default באותה חתימה, אין מנצח: המחלקה חייבת לדרוס את המתודה, אחרת הקוד לא מתקמפל.
  4. בתוך הדריסה אפשר לפנות לגרסה של ממשק מסוים בכתיב Lamp.super.color().
Java
interface Lamp    { default String color() { return "warm"; } }
interface DimLamp extends Lamp { default String color() { return "dim"; } }

class Fixture {
    public String color() { return "steel"; }
}

class DeskLamp extends Fixture implements Lamp { }     // rule 1: the class hierarchy wins
class NightLight implements Lamp, DimLamp { }          // rule 2: the more specific interface wins

public class Rules {
    public static void main(String[] args) {
        System.out.println(new DeskLamp().color());
        System.out.println(new NightLight().color());
    }
}
פלט
steel
dim
Java
interface Lamp   { default String color() { return "warm"; } }
interface Screen { default String color() { return "cold"; } }

class SmartPanel implements Lamp, Screen { }   // two unrelated defaults, no override
פלט
SmartPanel.java:4: error: class SmartPanel inherits unrelated defaults for color() from types Lamp and Screen
class SmartPanel implements Lamp, Screen { }   // two unrelated defaults, no override
^
1 error
תרחיש 9: מצפן שמשלב שני default, והטיפוס המוצהר לא מכריע
Java
interface North { default String dir() { return "N"; } }
interface East  { default String dir() { return "E"; } }

public class Compass implements North, East {
    public String dir() {                        // required: the defaults clash
        return East.super.dir() + "-" + North.super.dir() + "!";
    }

    public static void main(String[] args) {
        North n = new Compass();                 // declared type North, object Compass
        System.out.println(n.dir());
    }
}
פלט
E-N!
  • שני הממשקים מביאים dir() עם גוף, ואין קשר ביניהם. Compass דורסת את dir(), ולכן הקוד מתקמפל.
  • המשתנה n מוצהר כ-North, אבל האובייקט שנוצר הוא Compass.
  • dir() היא מתודת מופע, ולכן בזמן ריצה מופעלת הגרסה של המחלקה שהאובייקט שייך אליה, כלומר זו של Compass.
  • היא מצרפת קודם את מה ש-East.super.dir() מחזירה (E), אחר כך מקף, אחר כך את מה ש-North.super.dir() מחזירה (N), ובסוף סימן קריאה.

שני דברים לא השפיעו כאן: הטיפוס המוצהר North לא גרם להפעלת ה-default של North, והסדר שבו הממשקים כתובים אחרי implements לא שינה דבר. התוצאה נקבעה רק לפי הגוף של Compass.dir().

טעויות נפוצות
  • בממשק אי אפשר לכתוב גוף של מתודה, נקודה. זה היה נכון לפני Java 8. מאז יש default ו-static, מ-Java 9 גם private, וב-C# יש default interface members מגרסה 8.
  • כששני ממשקים מתנגשים, הממשק שכתוב אחרון ב-implements מנצח. הסדר לא משחק תפקיד. בהתנגשות בין ממשקים שאין ביניהם קשר המחלקה חייבת לדרוס, אחרת שגיאה.
  • אם המשתנה מוצהר מטיפוס של ממשק מסוים, יופעל ה-default של אותו ממשק. בזמן ריצה מופעלת הגרסה של האובייקט בפועל, כאן הדריסה שכתובה במחלקה.
  • מתודה static של ממשק אפשר לקרוא גם דרך שם המחלקה המממשת. היא לא עוברת בירושה. רק Greeter.of(...) מתקמפל.
בדקו את עצמכם
המחלקה Amphibian מממשת את Driver ואת Sailor. בשני הממשקים יש default String travel(), ואין קשר ירושה ביניהם. Amphibian לא כותבת travel() משלה. מה התוצאה?

הקוד לא מתקמפל: המחלקה מקבלת שני default שאין ביניהם קשר, באותה חתימה, ולכן היא חייבת לדרוס את travel().

ואם Sailor הייתה מרחיבה את Driver ודורסת אצלה את travel()?

אז אין התנגשות: הגרסה של Sailor, הממשק הספציפי יותר, נבחרת, והקוד מתקמפל.

ב-C#, הממשק IGreeter מגדיר Greet() עם גוף, והמחלקה Kiosk מממשת אותו בלי לכתוב Greet. האם new Kiosk().Greet() מתקמפל?

לא. ב-C# המחלקה לא יורשת את החבר, ויש לקרוא לו דרך הפניה מטיפוס IGreeter.

חזרה לתוכן העניינים

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

מחלקה אבסטרקטית (abstract class) היא מחלקה שאסור ליצור ממנה מופע ישיר. מותר לשלב בה מתודות מופשטות שאין להן גוף יחד עם מתודות רגילות שיש בהן קוד.

בדומה לממשק, גם היא קובעת מה היורשות חייבות לממש. ההבדלים ביניהם הם מה שנשאל:

היבטממשקמחלקה אבסטרקטית
שדות מופעאין, רק קבועיםיש, כמה שצריך
בנאיםאין בכלליש, והיורשות מפעילות אותם דרך super(...)
הרשאות של החבריםבעיקר publicכל ההרשאות, כולל protected ו-private
קוד עם גוףב-Java: מתודות default ו-static (מ-Java 8) ו-private (מ-Java 9). ב-C#: default interface members (מ-C# 8)כל סוג של מתודה
כמה אפשר לצרף למחלקה אחתבלי הגבלהאחת בלבד
מה היא אומרת על המחלקהיכולת: מה האובייקט יודע לעשותזהות: מאיזה סוג האובייקט

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

והמחיר? מחלקה יכולה לרשת ממחלקה אחת בלבד. יורשת שבחרה במחלקה האבסטרקטית שלכם כבר לא תוכל לרשת ממחלקה אחרת, ואילו ממשקים אפשר לצרף כמה שרוצים.

שתי עובדות שמבלבלות: מחלקה אבסטרקטית לא חייבת שכל המתודות שלה יהיו מופשטות, ומותר שיהיו בה חברים protected.

בפרויקטים אמיתיים משלבים את השתיים: הממשק הוא החוזה, ומחלקה אבסטרקטית מממשת חלק ממנו ומרכזת את הקוד המשותף.

Java
interface Payable {                                      // the contract
    long amountCents();
    String payee();
}

abstract class BasePayable implements Payable {          // shared state and code
    private final String payee;
    protected BasePayable(String payee) { this.payee = payee; }
    public String payee() { return payee; }
    public String receipt() { return payee() + ": " + amountCents() / 100.0; }
    // amountCents() stays abstract here
}

class Salary extends BasePayable {
    private final long monthly;
    Salary(String who, long monthly) { super(who); this.monthly = monthly; }
    public long amountCents() { return monthly; }
}

class Refund implements Payable {                        // skips the base, implements directly
    public long amountCents() { return 1250; }
    public String payee() { return "customer #88"; }
}

public class Payroll {
    public static void main(String[] args) {
        Payable[] all = { new Salary("Yael", 1530000), new Refund() };
        for (Payable p : all) System.out.println(p.payee() + " gets " + p.amountCents());
        System.out.println(new Salary("Omer", 990050).receipt());
    }
}
פלט
Yael gets 1530000
customer #88 gets 1250
Omer: 9900.5

הקוד שמשתמש באובייקטים מכיר רק את Payable. Salary מקבלת את השם, את הבנאי ואת receipt() מ-BasePayable, ו-Refund מוותרת על הבסיס ומממשת את הממשק ישירות. השדה payee יושב במחלקה האבסטרקטית, והממשק עצמו נשאר בלי מצב.

תרחיש 10: Exporter: ממשק או מחלקת בסיס עם מתודות וירטואליות

צוות כותב רכיבים שמייצאים דוחות ל-PDF, ל-CSV ול-Excel, ומתלבט אם Exporter יהיה ממשק או מחלקת בסיס עם מתודות וירטואליות.

לכל רכיב ייצוא צריכים להיות fileName ו-createdAt, ומתודה משותפת שמוסיפה לקובץ חותמת זמן.

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

ההחלטה: ממשק Exporter כחוזה, ומחלקה אבסטרקטית AbstractExporter שמחזיקה את השדות ומממשת את החלק המשותף. רכיב ה-Excel יממש את הממשק ישירות.

טעויות נפוצות
  • מחלקה יכולה לרשת משתי מחלקות אבסטרקטיות, כי הן לא מחלקות רגילות. גם מחלקה אבסטרקטית היא מחלקה, ומותרת אחת בלבד.
  • גם בממשק וגם במחלקת בסיס אפשר להחזיק שדות מופע, וההבדל ביניהם רק בשם. לממשק אין שדות מופע. מצב משותף יכול לשבת רק במחלקה.
  • ממשק מחייב את כל המחלקות המממשות להגדיר בנאי public. ממשק לא קובע דבר לגבי בנאים, וגם אין לו כאלה.
  • מתודות וירטואליות פועלות בזמן קומפילציה, וממשקים בזמן ריצה. בשתי הדרכים הקריאה מוכרעת בזמן ריצה, לפי האובייקט בפועל.
  • במחלקה אבסטרקטית כל המתודות מופשטות. מותר לכתוב בה מתודות רגילות, כמו receipt() ו-payee() ב-BasePayable.
  • למחלקה שמממשת ממשק לא יכולים להיות בנאים. למחלקה יש בנאים כרגיל, כמו Salary(String, long). רק לממשק אין.
  • יורשת מוגבלת למה שמחלקת הבסיס הגדירה ולא מוסיפה מתודות. יורשת מוסיפה מתודות ושדות משלה כרצונה.
  • השילוב של ממשק עם מחלקה אבסטרקטית נועד לעקוף את האיסור לרשת מכמה מחלקות. השילוב נותן חוזה וקוד משותף. מחלקה עדיין יורשת ממחלקה אחת לכל היותר.
  • ממשק לא מאפשר פולימורפיזם, כי אין בו מימוש לדרוס. ממשק הוא מהכלים המרכזיים לפולימורפיזם: כל מחלקה מממשת נותנת התנהגות משלה לאותה קריאה.
בדקו את עצמכם
במשחק, לכל הדמויות יש name ו-hp, ובנאי שמאתחל את שניהם. איפה נכון להגדיר אותם: בממשק GameCharacter או במחלקה אבסטרקטית GameCharacter?

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

איזה מחיר משלמת כל דמות בעקבות הבחירה הזו?

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

חזרה לתוכן העניינים

Polymorphism: פולימורפיזם, קריאה אחת והתנהגויות רבות

פולימורפיזם בזמן ריצה: התגובה נקבעת לפי האובייקט

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

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

הצורה שהכי חשוב להבין נקראת subtype polymorphism, והיא פועלת בזמן ריצה:

  • משתנה מטיפוס הבסיס רשאי להחזיק אובייקט של כל מחלקה נגזרת, למשל Instrument i = new Drum();.
  • כשקוראים דרכו למתודה שנדרסה, רצה הגרסה של המחלקה שהאובייקט באמת שייך אליה, ולא הגרסה של הטיפוס שהמשתנה הוצהר איתו.
  • מכיוון שהבחירה נעשית רק כשהתוכנית רצה, קוראים לה dynamic dispatch או late binding.
Java
class Instrument {
    String play() { return "(silence)"; }
}
class Drum extends Instrument {
    String play() { return "Boom"; }
}
class Flute extends Instrument {
    String play() { return "Tweet"; }
}

public class Band {
    public static void main(String[] args) {
        Instrument[] stage = { new Flute(), new Instrument(), new Drum() };
        for (Instrument i : stage) {
            System.out.println(i.play());         // one line of code, three behaviours
        }
    }
}
פלט
Tweet
(silence)
Boom

הקריאה i.play() כתובה פעם אחת, ובכל סיבוב של הלולאה היא מפעילה מימוש אחר. סדר השורות בפלט הוא סדר האובייקטים במערך.

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

חשוב להבדיל בין פולימורפיזם לבין שלושת העקרונות האחרים של תכנות מונחה עצמים:

  • ירושה (Inheritance): מחלקה חדשה נבנית על מחלקה קיימת ומקבלת ממנה שדות ומתודות.
  • כימוס (Encapsulation): המצב הפנימי של האובייקט מוסתר, והרשאות הגישה שומרות עליו.
  • הפשטה (Abstraction): מציגים את מה שחשוב למשתמש ומסתירים את פרטי הביצוע.

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

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

טעויות נפוצות
  • פולימורפיזם הוא המנגנון שבו מחלקה נבנית על גבי מחלקה אחרת וממשיכה את התוכן שלה. זו הגדרה של ירושה. פולימורפיזם עוסק במה שקורה כשקוראים למתודה דרך הטיפוס המשותף.
  • פולימורפיזם הוא הסתרה של המצב הפנימי מקוד חיצוני. זה כימוס.
  • קריאה דרך ממשק מגיעה למימוש שנבחר לפי הטיפוס המוצהר, כבר בקומפילציה. המימוש נבחר בזמן ריצה, לפי המחלקה של האובייקט שההפניה מצביעה עליו.
  • כשהתוכנית רצה, הטיפוס שכתוב בהצהרה של המשתנה מתעדכן לפי האובייקט שהוצב בו. הטיפוס המוצהר נקבע פעם אחת בקוד. מה שמתחלף הוא האובייקט שהמשתנה מפנה אליו.
  • כל המממשים של ממשק אחד חייבים לכתוב גוף זהה למתודות שלו. כל אחת כותבת גוף משלה, ובזכות זה אותה קריאה מתנהגת אחרת.
בדקו את עצמכם
Discount d = new SeasonalDiscount();, ו-SeasonalDiscount מספקת מימוש משלה ל-apply(). איזה גוף רץ בקריאה d.apply(100)?

הגוף של SeasonalDiscount. הבחירה נעשית בזמן ריצה לפי האובייקט, לא לפי הטיפוס Discount.

איזה מהמושגים ירושה, כימוס, הפשטה ופולימורפיזם מתאר את מה שקורה כש-i.play() מחזירה Boom עבור תוף ו-Tweet עבור חליל?

פולימורפיזם.

חזרה לתוכן העניינים

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

כל משתנה הפניה נושא שני טיפוסים בו בזמן:

  • הטיפוס המוצהר (static type), זה שכתוב בהצהרה: Instrument ב-Instrument i.
  • הטיפוס בפועל (runtime type), המחלקה של האובייקט שהמשתנה מצביע עליו כרגע: Guitar ב-new Guitar().

שני כללים משלימים מסבירים כמעט כל שאלת פלט:

  1. המהדר בודק רק את הטיפוס המוצהר, ומתיר לקרוא רק למתודות שקיימות בו.
  2. מתוך המתודות האלה, הגרסה שתרוץ נבחרת בזמן ריצה לפי הטיפוס בפועל.
תרחיש 11: גיטרה שמוחזקת כ-Instrument ומתודה שקיימת רק בה
Java
class Instrument {
    String play() { return "(silence)"; }
}
class Guitar extends Instrument {
    String play() { return "Strum"; }
    void tune() { System.out.println("tuning six strings"); }
}

public class Shop {
    public static void main(String[] args) {
        Instrument i = new Guitar();
        i.tune();                                 // tune() exists only in Guitar
    }
}
פלט
Shop.java:12: error: cannot find symbol
        i.tune();                                 // tune() exists only in Guitar
         ^
  symbol:   method tune()
  location: variable i of type Instrument
1 error

האובייקט שנוצר הוא אכן Guitar, ויש לו tune(). אבל ההחלטה אם לאשר את השורה מתקבלת בקומפילציה, מול הטיפוס Instrument, ובו אין מתודה כזו.

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

כדי להגיע ל-tune() צריך המרה מפורשת כלפי מטה (downcast): ((Guitar) i).tune().

המרה כלפי מעלה (upcast), מ-Guitar ל-Instrument, קורית מעצמה. המרה כלפי מטה חייבת להיכתב במפורש, והיא נבדקת כשהתוכנית רצה. אם האובייקט אינו מהטיפוס המבוקש, Java זורקת ClassCastException:

Java
class Instrument { }
class Guitar extends Instrument {
    void tune() { System.out.println("tuning six strings"); }
}
class Drum extends Instrument { }

public class Casts {
    public static void main(String[] args) {
        Instrument i = new Guitar();              // upcast: automatic
        ((Guitar) i).tune();                      // downcast: explicit, checked at run time

        Instrument j = new Drum();
        if (j instanceof Guitar) ((Guitar) j).tune();
        else System.out.println("not a guitar, skipped");

        ((Guitar) j).tune();                      // compiles, fails at run time
    }
}
פלט
tuning six strings
not a guitar, skipped
Exception in thread "main" java.lang.ClassCastException: Drum cannot be cast to Guitar
	at Casts.main(Casts.java:16)
נוסח ההודעה בפלט הוא של Java 8. ב-JDK חדשים יותר ההודעה ארוכה יותר ומזכירה גם את המודול ואת ה-class loader של כל מחלקה, אבל החריגה היא אותה ClassCastException.

ב-C# המרה כזו זורקת InvalidCastException. האופרטור as מחזיר null במקום לזרוק, וכדי לבדוק מראש כותבים instanceof ב-Java או is ב-C#:

C#
using System;

class Instrument { }
class Guitar : Instrument { public void Tune() => Console.WriteLine("tuning"); }
class Drum : Instrument { }

class Program
{
    static void Main()
    {
        Instrument j = new Drum();

        Guitar g = j as Guitar;                    // no exception: null when the type does not match
        Console.WriteLine(g == null ? "as gave null" : "as gave a guitar");

        if (j is Guitar real) real.Tune();         // check first, then use
        else Console.WriteLine("is said no");

        try { ((Guitar)j).Tune(); }                // a plain cast throws
        catch (InvalidCastException e) { Console.WriteLine(e.GetType().Name); }
    }
}
פלט
as gave null
is said no
InvalidCastException
טעויות נפוצות
  • השורה i.tune() עוברת, כי בזמן ריצה האובייקט הוא Guitar. המהדר מחליט לפני שיש אובייקט, לפי הטיפוס המוצהר בלבד.
  • הקוד מתקמפל, ובהרצה נזרקת ClassCastException. אין בשורה הזו המרה בכלל. היא נעצרת כבר בהידור.
  • הקוד מתקמפל ופשוט לא מדפיס כלום. קוד שלא עובר הידור לא רץ ולא מדפיס.
  • downcast תמיד בטוח, כי המהדר בודק אותו. המהדר מאשר המרה בין טיפוסים קשורים, אבל הבדיקה האמיתית נעשית בזמן ריצה, והיא נכשלת אם האובייקט מסוג אחר.
בדקו את עצמכם
Device d = new Printer3D();, ורק ל-Printer3D יש heatNozzle(). מה קורה בשורה d.heatNozzle();, ומה בשורה ((Printer3D) d).heatNozzle();?

הראשונה היא שגיאת הידור, כי ל-Device אין מתודה כזו. השנייה מתקמפלת ורצה, כי האובייקט באמת Printer3D.

ואם d היה מצביע על Scanner, שגם הוא יורש מ-Device?

השורה עם ההמרה עדיין מתקמפלת, אבל בזמן ריצה נזרקת ClassCastException.

חזרה לתוכן העניינים

העמסה (Overloading) ודריסה (Overriding): מי מחליט ומתי

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

העמסה (Overloading)דריסה (Overriding)
מה מגדיריםכמה מתודות עם אותו שם ורשימות פרמטרים שונותמחלקה נגזרת כותבת מחדש מתודה של מחלקת האב, באותה חתימה
מתי נעשית הבחירהבקומפילציהבזמן ריצה
לפי מההטיפוסים המוצהרים של הארגומנטיםהמחלקה של האובייקט בפועל
צריך ירושה?לא, אפשר בתוך מחלקה אחתכן
כינויפולימורפיזם סטטיפולימורפיזם דינמי

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

Java
public class Meter {
    int read()    { return 7; }
    double read() { return 7.0; }              // only the return type differs
}
פלט
Meter.java:3: error: method read() is already defined in class Meter
    double read() { return 7.0; }              // only the return type differs
           ^
1 error

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

Java
public class Logger {
    static void log(CharSequence c) { System.out.println("log(CharSequence)"); }
    static void log(String s)       { System.out.println("log(String)"); }

    public static void main(String[] args) {
        CharSequence text = "disk full";
        log(text);          // declared type CharSequence decides, not the String inside
        log("disk full");   // declared type String
        log(null);          // both fit; String is the more specific one
    }
}
פלט
log(CharSequence)
log(String)
log(String)

בקריאה הראשונה text מחזיק מחרוזת, ובכל זאת נבחרה log(CharSequence). ההחלטה נעשתה בקומפילציה, מול הטיפוס המוצהר. ב-log(null) שתי הגרסאות מתאימות, ו-String מנצחת כי היא מממשת את CharSequence ולכן ספציפית יותר.

כששתי הגרסאות מקבלות טיפוסים שאין ביניהם קשר, ל-null אין גרסה ספציפית יותר, והקריאה עמומה:

Java
public class Logger {
    static void log(String s)        { }
    static void log(StringBuilder b) { }       // unrelated to String

    public static void main(String[] args) {
        log(null);
    }
}
פלט
Logger.java:6: error: reference to log is ambiguous
        log(null);
        ^
  both method log(String) in Logger and method log(StringBuilder) in Logger match
1 error

ב-C# אותו מצב מסתיים בשגיאה CS0121:

C#
class Logger
{
    static void Log(string s) { }
    static void Log(System.Text.StringBuilder b) { }

    static void Main()
    {
        Log(null);
    }
}
פלט
Program.cs(8,9): error CS0121: The call is ambiguous between the following methods or properties: 'Logger.Log(string)' and 'Logger.Log(StringBuilder)'

הכללים של דריסה ב-Java:

  • החתימה זהה: אותו שם ואותה רשימת פרמטרים.
  • טיפוס ההחזרה זהה, או תת-טיפוס שלו (covariant return, מ-Java 5).
  • ההרשאה לא צרה יותר מזו של המתודה הנדרסת.
  • אסור להצהיר על checked exceptions רחבות יותר ממה שהמתודה המקורית מצהירה.
  • התגית @Override מבקשת מהמהדר לוודא שזו באמת דריסה, ומתריעה אם לא.

ב-C# דריסה מחייבת שהמתודה בבסיס תסומן virtual או abstract, ושהמתודה בנגזרת תסומן override. הפרטים בהמשך, בסעיף על פונקציות וירטואליות ב-C#. ב-C# 9 נוספה תמיכה בטיפוס החזרה covariant.

טעויות נפוצות
  • העמסה מוכרעת לפי האובייקט בפועל, ודריסה לפי הטיפוסים המוצהרים. בדיוק להפך: העמסה לפי הטיפוסים המוצהרים, בקומפילציה, ודריסה לפי האובייקט, בזמן ריצה.
  • העמסה דורשת ירושה, ודריסה אפשרית גם בלי קשר בין המחלקות. שוב להפך: העמסה קיימת גם במחלקה אחת, ודריסה קיימת רק בין מחלקת אב למחלקה נגזרת.
  • כדי להעמיס מספיק לשנות את טיפוס ההחזרה. המהדר מחזיר is already defined. צריך רשימת פרמטרים שונה.
  • ההעמסה נבחרת כשהתוכנית רצה. היא נבחרת בקומפילציה, וזו הסיבה ש-log(text) הפעילה את גרסת CharSequence.
  • כמה מתודות בשם זהה עם פרמטרים שונים, בתוך מחלקה אחת, הן דוגמה לפולימורפיזם דרך ממשק. זו העמסה. פולימורפיזם דרך ממשק הוא כמה מחלקות שמממשות את אותן מתודות.
בדקו את עצמכם
יש שתי מתודות, render(Widget w) ו-render(Button b), ו-Button יורשת מ-Widget. הקוד מריץ Widget w = new Button(); render(w);. איזו גרסה נקראת?

render(Widget). ההעמסה נבחרת בקומפילציה לפי הטיפוס המוצהר של w, שהוא Widget, גם אם בזמן ריצה הוא מחזיק Button.

ומה ייבחר ב-render(null)?

render(Button), כי שתי הגרסאות מתאימות ו-Button ספציפית יותר (היא תת-טיפוס של Widget).

חזרה לתוכן העניינים

מה לא נבחר בזמן ריצה: static, שדות, private ו-final

רק מתודות מופע שנדרסו נבחרות לפי האובייקט. שני דברים נבחרים תמיד לפי הטיפוס המוצהר:

  • מתודה static: מתודה סטטית עם אותה חתימה במחלקה נגזרת לא דורסת את זו של האב, אלא מסתירה אותה (hiding). הקריאה נקבעת לפי הטיפוס המוצהר.
  • שדה: שדה עם אותו שם במחלקה נגזרת מסתיר את השדה של האב, והגישה נקבעת לפי הטיפוס המוצהר.

מתודות private ו-final אי אפשר לדרוס בכלל. final נחסמת במפורש, ו-private לא עוברת בירושה, כך שמתודה באותו שם בנגזרת היא מתודה חדשה ולא דריסה:

Java
class Door {
    final void lock() { }
    private void oil() { }
}
class SafeDoor extends Door {
    void lock() { }                            // final cannot be overridden
    @Override void oil() { }                   // private is not inherited: nothing to override
}
פלט
Locks.java:6: error: lock() in SafeDoor cannot override lock() in Door
    void lock() { }                            // final cannot be overridden
         ^
  overridden method is final
Locks.java:7: error: method does not override or implement a method from a supertype
    @Override void oil() { }                   // private is not inherited: nothing to override
    ^
2 errors
תרחיש 12: שלושה ביטויים באותה שורה, שלוש הכרעות שונות
Java
class Gadget {
    static String brand() { return "Generic"; }
    String model = "G-1";
    String power() { return "5W"; }
}
class Phone extends Gadget {
    static String brand() { return "Nova"; }   // hides Gadget.brand(), does not override
    String model = "N-7";                      // hides Gadget.model
    String power() { return "18W"; }           // overrides
}

public class Store {
    public static void main(String[] args) {
        Gadget g = new Phone();
        System.out.println(g.brand() + " / " + g.model + " / " + g.power());
        Phone p = (Phone) g;
        System.out.println(p.brand() + " / " + p.model + " / " + p.power());
    }
}
פלט
Generic / G-1 / 18W
Nova / N-7 / 18W
  • g.brand(): מתודה סטטית, ולכן נבחרת לפי Gadget, הטיפוס המוצהר. יוצא Generic.
  • g.model: שדה, ולכן נקרא לפי Gadget. יוצא G-1.
  • g.power(): מתודת מופע שנדרסה, ולכן רצה הגרסה של Phone, האובייקט בפועל. יוצא 18W.

בשורה השנייה מדובר באותו אובייקט בדיוק, אבל המשתנה p מוצהר כ-Phone, ולכן גם המתודה הסטטית וגם השדה מגיעים מ-Phone. רק power() לא הושפעה מהחלפת הטיפוס המוצהר.

Java מתירה לקרוא למתודה סטטית דרך משתנה, כמו g.brand(), אבל זה מטעה את מי שקורא את הקוד. עדיף לכתוב Gadget.brand().
טעויות נפוצות
  • גם מתודה static נבחרת לפי המחלקה של האובייקט. מתודה סטטית לא שייכת לאובייקט. היא נבחרת לפי הטיפוס המוצהר, כמו g.brand() שהחזירה Generic.
  • מתודת protected שנדרסה נבחרת לפי טיפוס המשתנה, כי היא לא public. ההרשאה לא משנה את אופן הבחירה. דריסה נבחרת לפי האובייקט, בכל הרשאה.
  • מימוש של מתודה מופשטת נבחר לפי הטיפוס שהמשתנה הוצהר איתו. הוא נבחר בזמן ריצה, לפי האובייקט, כמו כל דריסה.
  • שדות מתנהגים כמו מתודות שנדרסו. שדה עם אותו שם רק מסתיר את השדה של האב, והגישה נקבעת לפי הטיפוס המוצהר.
בדקו את עצמכם
ב-Atlas וב-SatelliteAtlas, שיורשת ממנה, יש static int zoom(), שמחזירות 3 ו-7 בהתאמה. מה מחזיר m.zoom() אחרי Atlas m = new SatelliteAtlas();?

3. מתודה סטטית מוסתרת ולא נדרסת, ולכן נבחרת לפי Atlas, הטיפוס המוצהר.

אילו zoom() הייתה מתודת מופע רגילה בשתי המחלקות, מה היה מוחזר?

7, כי אז זו דריסה, והגרסה נבחרת לפי האובייקט, SatelliteAtlas.

חזרה לתוכן העניינים

פולימורפיזם בתכנון: להוסיף בלי לשנות, ולהפחית צימוד

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

זה עיקרון Open/Closed: יחידת קוד צריכה להיות פתוחה להרחבה וסגורה לשינוי.

תרחיש 13: משלוחים: ענף חדש בכל פעם, או רק מחלקה חדשה
Java
import java.util.*;

class Envelope { }
class Box      { double kilos = 3; }

interface Parcel { double shippingCost(); }

class Letter implements Parcel {
    public double shippingCost() { return 4.5; }
}
class Carton implements Parcel {
    private final double kilos;
    Carton(double kilos) { this.kilos = kilos; }
    public double shippingCost() { return 12 + 2 * kilos; }
}
class Pallet implements Parcel {                     // added later: totalCost() is untouched
    public double shippingCost() { return 180; }
}

public class Shipping {
    // without polymorphism: every new kind means another branch here
    static double costByType(List<Object> items) {
        double sum = 0;
        for (Object o : items) {
            if (o instanceof Envelope) sum += 4.5;
            else if (o instanceof Box) sum += 12 + 2 * ((Box) o).kilos;
        }
        return sum;
    }

    // with polymorphism: each parcel prices itself
    static double totalCost(List<Parcel> items) {
        double total = 0;
        for (Parcel p : items) total += p.shippingCost();
        return total;
    }

    public static void main(String[] args) {
        System.out.println(costByType(Arrays.<Object>asList(new Envelope(), new Box())));
        System.out.println(totalCost(Arrays.<Parcel>asList(new Letter(), new Carton(3), new Pallet())));
    }
}
פלט
22.5
202.5

costByType מכירה כל סוג חבילה בשמו. כדי להוסיף משטח (pallet) צריך לפתוח אותה שוב ולהוסיף instanceof, המרה ונוסחה. גם עיצוב עם שדה kind ו-switch, או עיצוב שעושה cast לכל פריט לפי הסוג שלו, מחייב את אותה עריכה בכל תוספת.

ב-totalCost הממשק Parcel מגדיר shippingCost(), והלולאה פשוט קוראת לה על כל איבר. Pallet נוספה כמחלקה חדשה, ו-totalCost לא השתנתה בתו אחד.

צימוד (Coupling) מודד עד כמה רכיב אחד תלוי ברכיב אחר. קוד שתלוי במחלקה מסוימת צריך להשתנות בכל פעם שהמחלקה משתנה או מוחלפת.

קוד שתלוי רק בחוזה של ממשק לא מכיר את המימושים, ולכן אפשר להחליף אותם או לשנות אותם בלי לשנות אותו. מאותה סיבה ממשק מאפשר לשים מימוש דמה (mock) במקום המימוש האמיתי בבדיקות, כפי שראיתם בחלק על Singleton ובדיקות יחידה.

מה בדיוק מוריד כאן את הצימוד? העובדה שהקוד הצורך מזכיר בשמו רק את Parcel. הסתרת שדות מאחורי private היא כימוס, עיקרון אחר, והיא לא משנה במה totalCost תלויה.

גם המהדר לא תורם לזה: הוא מכיר רק את החוזה ולא יודע איזה מימוש יגיע בזמן ריצה. ואין צורך בהורה משותף: Letter ו-Pallet לא קשורות זו לזו בירושה, ומה שמחבר ביניהן הוא רק הממשק שהן מממשות.

טעויות נפוצות
  • בכל פעם שנוסף סוג, הקוד שמשתמש באובייקטים צריך עוד ענף של instanceof. זה בדיוק מה שפולימורפיזם חוסך. ב-totalCost מחלקה חדשה לא דרשה שום שינוי בקוד הקורא.
  • שינוי במחלקת הבסיס מגיע אוטומטית לכל היורשות, והן לא יכולות להתנהג אחרת. יורשות דורסות מתודות ומגדירות התנהגות משלהן. זה כל העניין.
  • הצימוד יורד בזכות ממשקים משום שכל המחלקות המממשות חולקות מחלקת אב אחת. ממשק איננו מחלקת אב. המממשים חולקים חוזה, לא קוד ולא אב.
  • הצימוד יורד כי המהדר מאמת שכל קריאה מגיעה למימוש המדויק שלה. המהדר מכיר רק את החוזה. המימוש נבחר בזמן ריצה.
בדקו את עצמכם
אפליקציה מחשבת זמני הגעה לשליחים על אופניים ועל אופנוע, ועכשיו מצטרפים שליחים עם רחפן. איזה עיצוב יאפשר להוסיף רחפן בלי לשנות את הקוד שמציג את זמני ההגעה?

ממשק Courier עם etaMinutes(), שכל סוג שליח מממש. הקוד המציג קורא ל-etaMinutes() דרך הממשק, ו-DroneCourier נוסף כמחלקה חדשה.

מה מבדיל בין העיצוב הזה לבין מתודה שבודקת instanceof עבור כל סוג שליח?

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

חזרה לתוכן העניינים

פונקציות וירטואליות (Virtual function): הגרסה נבחרת בזמן ריצה

איך נבחרת הגרסה הנכונה: vtable וקריאה עקיפה

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

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

Java
class Sensor {
    String read() { return "generic reading"; }
    String unit() { return "units"; }
}

class ThermoSensor extends Sensor {
    @Override
    String read() { return "21.5"; }        // replaces only read()
}

public class SensorDemo {
    public static void main(String[] args) {
        Sensor s = new ThermoSensor();      // declared type Sensor, object ThermoSensor
        System.out.println(s.read() + " " + s.unit());
    }
}
פלט
21.5 units

המשתנה s מוצהר כ-Sensor, אבל read() שרצה בפועל היא של ThermoSensor. את unit() היורשת לא כתבה מחדש, ולכן רצה הגרסה שהגיעה בירושה.

איך זה נעשה מאחורי הקלעים? המימושים המקובלים (C++, ה-JVM וה-CLR) בנויים על אותו רעיון:

  1. לכל מחלקה נבנית טבלה אחת של כתובות המתודות הווירטואליות שלה. הטבלה נקראת vtable (virtual method table).
  2. אם המחלקה כתבה גרסה משלה למתודה, הכניסה בטבלה שלה מחזיקה את הכתובת של הגרסה הזו. אם לא, הכניסה מחזיקה את הכתובת שבטבלת מחלקת האב.
  3. בתוך כל אובייקט שמור מצביע אחד, אל הטבלה של המחלקה שממנה הוא נוצר.
  4. בקריאה וירטואלית הולכים מהאובייקט אל הטבלה שלו, שולפים את הכניסה של המתודה וקופצים לכתובת שנמצאה בה. זו קריאה עקיפה (indirect call).
כניסה בטבלהvtable של Sensorvtable של ThermoSensor
readSensor.readThermoSensor.read
unitSensor.unitSensor.unit (בירושה)

עקבו אחרי s.read() מהדוגמה: מהאובייקט אל הטבלה של ThermoSensor, משם אל השורה read, ומשם קפיצה אל ThermoSensor.read. שתי קריאות מהזיכרון וקפיצה אחת, ולא משנה אם בתוכנית יש שלוש מחלקות או שלושת אלפים.

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

לגמישות הזו יש צד שני. כשהמהדר מגיע לשורה s.read() הוא עוד לא יודע אם ב-s יהיה Sensor או ThermoSensor, ולכן הוא לא יכול להדביק במקום הקריאה את גוף המתודה (inlining), כמו שהוא עושה לא פעם בקריאה רגילה. לכן קריאה וירטואלית אף פעם לא מנצחת קריאה ישירה במהירות; מה שמרוויחים הוא האפשרות להוסיף סוג חיישן חדש בלי לגעת בקוד שקורא ל-read.

ב-JVM וב-CLR הסיפור נמשך בזמן ריצה. אם ה-JIT יודע שיש רק מימוש אחד של read שיכול להגיע לשורה הזו, או שבפועל רק ThermoSensor הגיעה אליה עד עכשיו, הוא מחליף את השליפה מהטבלה בקריאה ישירה ויכול אף להדביק את הגוף במקומה. לזה קוראים devirtualization, והוא מוחק את רוב העלות.

ועוד הבחנה חשובה: וירטואלית אין פירושו בלי גוף. בדרך כלל יש למתודה מימוש במחלקת הבסיס, והיורשות רשאיות להחליף אותו אבל לא חייבות. מתודה בלי גוף, שכל יורשת לא מופשטת חייבת לממש, נקראת abstract, וב-C++ קוראים לה pure virtual.

טעויות נפוצות
  • הגרסה של מתודה וירטואלית מוכרעת בהידור, לפי הטיפוס שבו הוצהר המשתנה. ההפך הוא הנכון: ההכרעה נעשית בזמן ריצה לפי המחלקה של האובייקט עצמו, כמו ש-s.read() הגיעה ל-ThermoSensor.
  • מתודה מוגדרת וירטואלית כדי שהמהדר יעתיק את גופה לנקודת הקריאה. כיוון שהיעד לא ידוע בזמן ההידור, דווקא קשה יותר להטמיע אותה. הטמעה אפשרית רק אחרי devirtualization.
  • וירטואלית היא מתודה שננעלה כ-final כדי שאיש לא יחליף אותה. final חוסמת דריסה, ואילו וירטואליות היא מה שמאפשר דריסה מלכתחילה.
  • virtual חוסכת זמן כי כתובת המתודה ידועה מראש. הכתובת נשלפת מהטבלה רק כשהקריאה מתבצעת. היתרון הוא גמישות, לא מהירות.
  • ברגע שמתודה וירטואלית, כל יורשת מחויבת לכתוב לה גוף חדש, אחרת אין הידור. חובה כזו קיימת רק במתודה abstract. מתודה וירטואלית רק פותחת אפשרות, ויורשת שלא דורסת פשוט מקבלת את גרסת הבסיס (כמו unit() אצל ThermoSensor).
  • virtual נועדה לכפות על כל היורשות התנהגות אחידה לפי חוזה קשיח. המטרה הפוכה: לאפשר לכל יורשת התנהגות משלה מאחורי אותה חתימה.
בדקו את עצמכם
ל-Instrument יש מתודות וירטואליות play() ו-tune(). Drum כותבת גרסה משלה רק ל-play(). מה יופיע בשתי הכניסות של הטבלה של Drum?

בכניסה של play תופיע הכתובת של Drum.play, ובכניסה של tune הכתובת של Instrument.tune, כי Drum לא דרסה אותה. קריאה ל-play דרך משתנה מטיפוס Instrument שמחזיק Drum עוברת דרך הטבלה של Drum ומגיעה ל-Drum.play.

למה המהדר לא תמיד מצליח להטמיע קריאה וירטואלית, ומי לפעמים כן מצליח?

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

חזרה לתוכן העניינים

Java: כל מתודת מופע וירטואלית מעצמה

ב-Java לא תמצאו מילת מפתח virtual. ההנחה היא הפוכה: כל מתודת מופע וירטואלית, אלא אם היא static, private או final.

  • final על מתודה: היורשות מקבלות אותה בירושה אבל לא יכולות להחליף אותה.
  • מתודות static, מתודות private ובנאים אינם נדרסים בכלל.
  • מתודה abstract (בלי גוף) היא מה ש-C++ מכנה pure virtual, ומחלקה שמכילה מתודה כזו חייבת להיות מוצהרת abstract בעצמה.
  • מתוך דריסה מגיעים לגרסה של האב בעזרת super.m().

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

Java
abstract class Exporter {
    // the shared skeleton, written once and locked
    final String export() {
        return open() + "|" + rows() + "|" + close();
    }
    protected String open()  { return "BEGIN"; }
    protected String close() { return "END"; }
    protected abstract String rows();          // every exporter must supply this
}

class CsvExporter extends Exporter {
    protected String rows() { return "a,b,c"; }
}

class XmlExporter extends Exporter {
    protected String rows() { return "<r/>"; }
    @Override
    protected String close() { return super.close() + "+checksum"; }   // reuses the parent text
}

public class Main {
    public static void main(String[] args) {
        Exporter[] all = { new CsvExporter(), new XmlExporter() };
        for (Exporter e : all) System.out.println(e.export());
    }
}
פלט
BEGIN|a,b,c|END
BEGIN|<r/>|END+checksum

export() שייכת לאב ומסומנת final, כך שאף יורשת לא תשבש את סדר הצעדים. בתוכה הקריאות ל-open(), rows() ו-close() וירטואליות, ולכן כל מייצא מקבל את השלד המשותף יחד עם הצעדים שהוא עצמו החליף. XmlExporter אף נעזרת ב-super.close() כדי להרחיב את הטקסט של האב במקום לכתוב אותו מחדש.

לדפוס הזה קוראים Template Method, ולמתודות שהיורשות ממלאות קוראים ווים (hooks). מאחר שהן מיועדות ליורשות ולא לקוד חיצוני, מתאים לסמן אותן protected, כמו בדוגמה.

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

וכך עונה המהדר על ניסיון לדרוס מתודה final:

Java
class Engine {
    final void ignite() { System.out.println("spark"); }
}

class Diesel extends Engine {
    void ignite() { System.out.println("glow plug"); }
}

public class IgniteDemo {
    public static void main(String[] args) { new Diesel().ignite(); }
}
פלט
IgniteDemo.java:6: error: ignite() in Diesel cannot override ignite() in Engine
    void ignite() { System.out.println("glow plug"); }
         ^
  overridden method is final
1 error
טעויות נפוצות
  • כדי שיורשת ב-Java תוכל להחליף מתודה, צריך לכתוב לפניה virtual. המילה הזו לא קיימת ב-Java. מתודות מופע וירטואליות מעצמן, וההגבלה נעשית בכיוון ההפוך, עם final.
  • אם מסמנים את מתודת האב static, כל יורשת תוכל להחליף בה רק את החלק שלה. מתודה סטטית שייכת למחלקה ולא נדרסת, ולכן שום קריאה אליה לא תגיע לגרסה של יורשת.
  • המקום הטבעי לקוד המשותף הוא מתודה abstract באב. abstract פירושה בלי גוף. הקוד המשותף יושב במתודה רגילה (בדוגמה: export), ורק הצעדים המשתנים יכולים להיות abstract.
בדקו את עצמכם
מותר לרשת מהמחלקה שלכם, אבל המתודה validate() חייבת להישאר זהה בכל היורשות. מה עושים?

מסמנים את validate() כ-final. סימון המחלקה כולה כ-final היה חוסם כל ירושה ממנה, וזה הרבה יותר ממה שנדרש.

האם יורשת ב-Java יכולה לדרוס את הבנאי של מחלקת האב?

לא. בנאים, כמו מתודות static ו-private, לא נדרסים. מבנאי היורשת אפשר רק לקרוא לבנאי האב עם super(...).

חזרה לתוכן העניינים

C#: virtual ו-override, ומה עושים new ו-sealed

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

  • במחלקת הבסיס: virtual (או abstract, שהיא וירטואלית גם בלי לכתוב זאת).
  • במחלקה היורשת: override.

אלה כל האפשרויות שעומדות בפני יורשת שמגדירה מתודה באותו שם ובאותה חתימה:

מה כתוב ביורשתמה זה אומרקריאה דרך משתנה מטיפוס הבסיס
override, והבסיס virtual או abstractדריסה של ממשרצה הגרסה של היורשת
newמתודה חדשה באותו שם, שמסתירה (hides) את זו של הבסיסרצה הגרסה של הבסיס
שום מילה, והבסיס virtualגם זו הסתרה, והמהדר מזהיר ב-CS0114רצה הגרסה של הבסיס
שום מילה, והבסיס אינו virtualהסתרה, עם אזהרה CS0108רצה הגרסה של הבסיס
sealed overrideדריסה שננעלת: מי שיורש מהיורשת לא יוכל לדרוס שוברצה הגרסה של היורשת
override מול מתודה שאינה virtualשגיאת הידור CS0506הקוד לא מתקמפל

CS0114 ו-CS0108 הן אזהרות ולא שגיאות: הקוד נבנה ורץ. ובתוך כל דריסה אפשר לפנות לגרסת הבסיס עם base.M().

תרחיש 14: שלוש יורשות, שלוש דרכים לכתוב את אותה מתודה
C#
Beverage[] cups = { new Tea(), new Coffee(), new Juice() };
Console.WriteLine(string.Join(", ", cups.Select(b => b.Label())));

Coffee c = new Coffee();
Console.WriteLine(c.Label());
Console.WriteLine(((Beverage)c).Label());

class Beverage { public virtual string Label() { return "plain drink"; } }
class Tea : Beverage { public override string Label() { return "tea"; } }
class Coffee : Beverage { public new string Label() { return "coffee"; } }
class Juice : Beverage { public string Label() { return "juice"; } }   // no keyword
פלט
Program.cs(11,40): warning CS0114: 'Juice.Label()' hides inherited member 'Beverage.Label()'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
tea, plain drink, plain drink
coffee
plain drink

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

  • Tea דורסת עם override, ולכן גם דרך מערך של Beverage רצה הגרסה שלה.
  • Coffee הגדירה מתודה חדשה עם new. דרך Beverage רואים רק את המתודה של הבסיס, ולכן מודפס plain drink.
  • Juice לא כתבה שום מילה. המהדר מזהיר ב-CS0114 ומתייחס לזה כהסתרה, ושוב רצה גרסת הבסיס.
  • דרך משתנה שמוצהר Coffee מודפס coffee, וההמרה חזרה ל-Beverage מחזירה את plain drink. בהסתרה, הטיפוס המוצהר הוא שמכריע.

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

C#
Lamp lamp = new DeskLamp();
lamp.Glow();
new DeskLamp().Glow();
lamp.Dim();

class Lamp {
    public void Glow() { Console.WriteLine("Lamp.Glow"); }
    public void Dim() { Console.WriteLine("Lamp.Dim"); }
}
class DeskLamp : Lamp {
    public new void Glow() { Console.WriteLine("DeskLamp.Glow"); }
    public void Dim() { Console.WriteLine("DeskLamp.Dim"); }   // no keyword, base not virtual
}
פלט
Program.cs(12,17): warning CS0108: 'DeskLamp.Dim()' hides inherited member 'Lamp.Dim()'. Use the new keyword if hiding was intended.
Lamp.Glow
DeskLamp.Glow
Lamp.Dim

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

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

עכשיו לצד של השגיאות. הקוד הבא לא מתקמפל, משתי סיבות שונות:

C#
class Account {
    public virtual decimal Fee() { return 10m; }
    public string Owner() { return "bank"; }
}
class Savings : Account {
    public sealed override decimal Fee() { return 2m; }
    public override string Owner() { return "me"; }       // CS0506
}
class YouthSavings : Savings {
    public override decimal Fee() { return 0m; }          // CS0239
}
class Program { static void Main() { } }
פלט
Program.cs(7,28): error CS0506: 'Savings.Owner()': cannot override inherited member 'Account.Owner()' because it is not marked virtual, abstract, or override
Program.cs(10,29): error CS0239: 'YouthSavings.Fee()': cannot override inherited member 'Savings.Fee()' because it is sealed

Savings מנסה לדרוס את Owner(), שלא סומנה virtual בבסיס (CS0506). YouthSavings מנסה לדרוס את Fee(), ש-Savings נעלה עם sealed override (CS0239). מתודה שלא ננעלה, כמו Describe בדוגמה הבאה, נשארת פתוחה לדריסה בכל דור, ו-base.Describe() מגיעה כל פעם לגרסה של הדור הקודם:

C#
Account a = new YouthSavings();
Console.WriteLine(a.Fee() + " " + a.Describe());

class Account {
    public virtual decimal Fee() { return 10m; }
    public virtual string Describe() { return "account"; }
}
class Savings : Account {
    public sealed override decimal Fee() { return 2m; }
    public override string Describe() { return "savings, base says " + base.Describe(); }
}
class YouthSavings : Savings {
    public override string Describe() { return "youth " + base.Describe(); }   // allowed: not sealed
}
פלט
2 youth savings, base says account
מתודה שנועדה רק לדריסה ולשימוש בתוך ההיררכיה מסמנים בדרך כלל protected virtual: המחלקה והיורשות שלה יכולות לקרוא לה ולדרוס אותה, וקוד מחוץ להיררכיה לא יכול לקרוא לה.
טעויות נפוצות
  • אם ליורשת יש מתודה באותו שם ובאותה חתימה, הקריאה תגיע אליה לפי האובייקט בפועל גם בלי override. בלי override אין דריסה אלא הסתרה, ודרך משתנה מטיפוס הבסיס רצה גרסת הבסיס, כמו אצל Juice.
  • השמטת override מול מתודה virtual עוצרת את ההידור. המהדר מוציא רק אזהרה, CS0114, והתוכנית נבנית ורצה.
  • שתי מתודות באותה חתימה, בבסיס וביורשת, יגרמו לחריגה כשהתוכנית תרוץ. אין פה שום דבר שמחכה לזמן ריצה. ההסתרה מוכרעת כולה בהידור, לכל היותר עם אזהרה.
  • new גורמת לשתי הגרסאות לרוץ, קודם של הבסיס ואחר כך של היורשת. רצה גרסה אחת בלבד: זו של הטיפוס שבו הוצהר המשתנה.
  • sealed override היא סוג של הסתרה. זו דריסה מלאה. sealed רק סוגרת את הדלת בפני דריסה נוספת בדורות הבאים.
  • מתודה שסומנה sealed הופכת למופשטת, בלי גוף. יש לה גוף רגיל, וההגבלה היא רק על דריסה נוספת. מתודה בלי גוף היא abstract.
  • virtual מעבירה את המתודה מהאובייקט אל המחלקה, ואז מפעילים אותה ישירות דרך שם המחלקה, בלי ליצור אובייקט. זה תיאור של static. מתודה וירטואלית היא מתודת מופע, ודווקא האובייקט קובע איזו גרסה תרוץ.
  • מסמנים virtual כדי לחסוך זיכרון, כי כל היורשות חולקות אז מימוש אחד. המטרה היא לאפשר מימוש שונה לפי סוג האובייקט, לא לשתף מימוש אחד.
  • virtual מודיעה למהדר שלמתודה אין גוף בבסיס. זה abstract. למתודה virtual יש גוף בבסיס, ויורשת יכולה להשאיר אותו כמו שהוא.
בדקו את עצמכם
Engine מגדירה public virtual string Start(), ו-Turbo יורשת ממנה וכותבת public new string Start(). התוכנית מריצה Engine e = new Turbo(); ואחר כך e.Start(). של מי הגרסה שרצה? ומה משתנה אם Turbo כותבת override במקום new?

עם new רצה הגרסה של Engine, כי Turbo רק הסתירה אותה והמשתנה מוצהר Engine. עם override רצה הגרסה של Turbo, כי זו דריסה, והטבלה של Turbo מצביעה לגרסה שלה.

B דורסת את M() עם sealed override, ו-C יורשת מ-B. מה קורה אם C כותבת override ל-M()? ומה אם היא כותבת new?

override נכשל בשגיאת CS0239, כי M ננעלה ב-B. עם new הקוד מתקמפל: זו מתודה חדשה שמסתירה, ודרך משתנה מטיפוס B או מטיפוס הבסיס תרוץ הגרסה של B.

חזרה לתוכן העניינים

C++: למה ה-Destructor של בסיס צריך virtual, ולמה Java ו-C# פטורות

C++ דומה כאן ל-C#: מתודה איננה וירטואלית עד שכותבים לפניה virtual, ומתודה pure virtual מסומנת בסיומת = 0.

ההבדל הגדול הוא בניהול הזיכרון. ב-C++ אין Garbage Collector: את מה שהוקצה עם new משחררים בעצמכם עם delete, ו-delete מפעיל את ה-Destructor (המפרק), הפונקציה שמשחררת את המשאבים שהאובייקט החזיק.

הבעיה צצה כשמשחררים אובייקט של יורשת דרך מצביע מטיפוס הבסיס. אם ה-Destructor של הבסיס אינו virtual, delete מכריע לפי טיפוס המצביע ולא לפי האובייקט. התקן מגדיר את זה כהתנהגות לא מוגדרת (undefined behaviour), ובפועל בדרך כלל ה-Destructor של היורשת פשוט מדולג, וכל מה שהוא היה אמור לשחרר נשאר תפוס.

C++
#include <iostream>

class Channel {
public:
    ~Channel() { std::cout << "~Channel\n"; }            // not virtual
    virtual void send() = 0;                              // pure virtual
};

class SocketChannel : public Channel {
    char* buffer;
public:
    SocketChannel() : buffer(new char[4096]) {}
    ~SocketChannel() { delete[] buffer; std::cout << "~SocketChannel (buffer freed)\n"; }
    void send() override { std::cout << "sending\n"; }
};

int main() {
    Channel* ch = new SocketChannel();
    ch->send();
    delete ch;                                            // undefined behaviour
}
פלט
main.cpp:20:5: warning: deleting object of abstract class type 'Channel' which has non-virtual destructor will cause undefined behavior [-Wdelete-non-virtual-dtor]
sending
~Channel

~SocketChannel לא הודפס, ו-4096 הבתים של buffer דלפו. g++ עם -Wall אף מזהיר מראש על המחיקה הזו (השורה הראשונה בפלט היא האזהרה שלו). התיקון הוא מילה אחת:

C++
#include <iostream>

class Channel {
public:
    virtual ~Channel() { std::cout << "~Channel\n"; }    // now virtual
    virtual void send() = 0;
};

class SocketChannel : public Channel {
    char* buffer;
public:
    SocketChannel() : buffer(new char[4096]) {}
    ~SocketChannel() override { delete[] buffer; std::cout << "~SocketChannel (buffer freed)\n"; }
    void send() override { std::cout << "sending\n"; }
};

int main() {
    Channel* ch = new SocketChannel();
    ch->send();
    delete ch;                                            // goes through the vtable
}
פלט
sending
~SocketChannel (buffer freed)
~Channel

עכשיו delete עובר דרך הטבלה הווירטואלית: קודם רץ ה-Destructor של היורשת, ואחריו, אוטומטית, זה של הבסיס. אם תכננתם את Channel כך שישתמשו בה דרך Channel*, ה-Destructor שלה חייב להיות virtual. המילה הזו לא קונה זמן, והיא גם לא משאירה את ~Channel לרוץ לבד: כל תפקידה הוא ש-~SocketChannel יגיע לתורו וישחרר את buffer.

ב-Java וב-C# השאלה הזו בכלל לא עולה. את הזיכרון מנהל Garbage Collector, שאוסף אובייקט כשכבר אין אליו אף הפניה חיה. אין delete שכותבים בעצמכם, ואין Destructor שרץ ברגע ידוע מראש.

  • אובייקט ב-Java לא נמחק ברגע שהמתודה שיצרה אותו חוזרת. אם הפניה אליו נשמרה במקום אחר, למשל ברשימה, הוא ממשיך לחיות.
  • המהדר לא מוסיף לכל מחלקה Destructor וירטואלי נסתר. פשוט אין בו צורך.
  • פולימורפיזם יש ב-Java במלואו. מה שחסר הוא רק שחרור ידני שצריך לעבור דרך מחלקת הבסיס.
ב-C# אפשר לכתוב ~Channel(), וזה נראה כמו Destructor של C++. בפועל זה finalizer, כלומר דריסה של Finalize, וה-Garbage Collector מריץ אותו מתי שהוא מחליט, בזמן שאי אפשר לדעת מראש.
טעויות נפוצות
  • Destructor וירטואלי נועד לזרז את delete. המטרה היא נכונות: שה-Destructor של היורשת ירוץ ושהמשאבים שלה ישוחררו.
  • כשה-Destructor של הבסיס virtual, delete מריץ רק אותו. הוא מריץ קודם את של היורשת ואחר כך את של הבסיס, כפי שהפלט של SocketChannel מראה.
  • Destructor וירטואלי גורם ל-delete להיות מוכרע בהידור לפי טיפוס המצביע. זה מה שקורה כשהוא לא וירטואלי, וזו בדיוק התקלה.
  • Java מוותרת על Destructor וירטואלי משום שהיא לא תומכת בפולימורפיזם בין מחלקות. יש בה פולימורפיזם מלא. הסיבה היא שאת הזיכרון משחרר ה-Garbage Collector ולא delete ידני.
  • ב-Java אובייקט נעלם ברגע שהמתודה שבה הוא נוצר מסתיימת. הוא נאסף רק כשאי אפשר עוד להגיע אליו מאף הפניה חיה, וזה יכול לקרות הרבה אחר כך.
בדקו את עצמכם
ב-C++, Cache יורשת מ-Storage, וה-Destructor של Cache משחרר מערך גדול. הקוד מבצע Storage* s = new Cache(); ואחר כך delete s;, וה-Destructor של Storage לא סומן virtual. מה צפוי לקרות, ומה מתקנים?

זו התנהגות לא מוגדרת, ובדרך כלל ה-Destructor של Cache לא ירוץ והמערך ידלוף. מוסיפים virtual ל-Destructor של Storage, ואז ירוץ קודם של Cache ואחריו של Storage.

כתבתם ~Report() במחלקה של C#. מתי הקוד שבתוכו ירוץ?

כשה-Garbage Collector יאסוף את האובייקט ויריץ את ה-finalizer, בזמן שאינו ידוע מראש. זה לא Destructor דטרמיניסטי כמו ב-C++.

חזרה לתוכן העניינים

IComparable: איך אובייקט קובע את הסדר הטבעי שלו

CompareTo: מה המספר המוחזר אומר

IComparable הוא ממשק של C# (.NET). מחלקה שמממשת אותו מצהירה מהו הסדר הטבעי שלה, כלומר הסדר שבו ימוינו המופעים שלה כשאף אחד לא ביקש סדר אחר. המופע עצמו יודע לומר אם הוא בא לפני מופע אחר מאותו סוג או אחריו, בערך כמו ספר שיודע איפה הוא עומד על המדף ביחס לשכן שלו.

הממשק קיים בשתי צורות:

צורהחתימהמה חשוב לדעת
System.IComparable (לא גנרי)int CompareTo(object obj)מקבל כל אובייקט. לפי המוסכמה, וכך נוהגים הטיפוסים המובנים, הוא זורק ArgumentException כשמגיע אובייקט מטיפוס אחר
IComparable<T> (גנרי)int CompareTo(T other)הצורה המומלצת: המהדר בודק את הטיפוס, ולטיפוסי ערך אין boxing
C#
IComparable boxed = 5;                     // the non-generic view of an int
Console.WriteLine(boxed.CompareTo(8));
try {
    Console.WriteLine(boxed.CompareTo("5"));   // a string, not an int
} catch (ArgumentException e) {
    Console.WriteLine(e.GetType().Name + ": " + e.Message);
}
פלט
-1
ArgumentException: Object must be of type Int32.

החוזה של a.CompareTo(b) מנוסח כולו דרך הסימן של התוצאה:

התוצאהפירושבמיון עולה
מספר שליליa קודם ל-ba יופיע לפני b
אפסמבחינת הסדר אין ביניהם הבדללא נקבע מי מהשניים ראשון
מספר חיוביa מגיע אחרי ba יופיע אחרי b

רק הסימן נחשב. אין דרישה שהתוצאה תהיה בדיוק -1, 0 או 1, ומימוש שמחזיר -17 או 250 עומד בחוזה לגמרי.

  • הטיפוס המוחזר הוא int: לא bool, ולא האובייקט הגדול מבין השניים.
  • ערכים שווים אינם מקרה חריג: מוחזר 0, בלי שום חריגה.
  • ב-.NET כל מופע נחשב גדול מ-null, ולכן x.CompareTo(null) מחזירה מספר חיובי.
  • int, double, string, DateTime ועוד טיפוסים מובנים כבר מממשים את הממשק.
C#
Console.WriteLine(12.CompareTo(4));
Console.WriteLine("kiwi".CompareTo("lime"));
Console.WriteLine(7.5.CompareTo(7.5));
Console.WriteLine("zebra".CompareTo(null));          // any instance beats null
Console.WriteLine(new DateTime(2020, 1, 1).CompareTo(new DateTime(2024, 6, 1)));
פלט
1
-1
0
1
-1

שלושה ממשקים יושבים קרוב ומתבלבלים בקלות עם IComparable:

ממשקמה הוא עושהההבדל מ-IComparable
IComparer<T>int Compare(T x, T y): אובייקט נפרד שמשווה בין שני אובייקטים אחריםמגדיר סדר חלופי מבחוץ, ומעבירים אותו למתודת המיון כפרמטר. Comparison<T> הוא אותו רעיון בצורת delegate
IEquatable<T>Equals: האם שני אובייקטים שווים בתוכןעונה רק על כן או לא, ולא קובע מי קודם
IEnumerableמעבר על איברי אוסףאין לו שום קשר להשוואה

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

טעויות נפוצות
  • כששני האובייקטים שווים, CompareTo מחזירה true. היא מחזירה int, ובמקרה של שוויון את הערך 0.
  • התוצאות החוקיות של CompareTo הן רק -1, 0 ו-1. כל שלילי, כל חיובי או 0. מי שמשתמש בתוצאה בודק רק את הסימן.
  • CompareTo מחזירה את המופע הגדול מבין השניים. היא מחזירה מספר שמתאר את היחס ביניהם, לא אחד מהם.
  • השוואה של שני ערכים זהים מסתיימת בחריגה. שוויון הוא תוצאה רגילה לגמרי: 0.
  • IComparable הוא אובייקט נפרד שמעבירים למיון כדי לקבל סדר אחר. זה IComparer. ב-IComparable המופע משווה את עצמו לאחר, והסדר הוא הסדר הטבעי.
  • IComparable משמש לבדוק אם התוכן של שני אובייקטים זהה. לשוויון יש את IEquatable<T> ואת Equals. IComparable עוסק בסדר.
  • IComparable הוא הכלי לסרוק אוסף ולבקר בכל איבר שבו. זה התפקיד של IEnumerable.
  • תוצאה שלילית אומרת ש-a ימוקם אחרי b. שלילי פירושו ש-a קודם. חיובי פירושו אחרי.
  • תוצאה שלילית מסמנת שאי אפשר להשוות בין השניים. בחוזה אין ערך כזה בכלל. שלילי הוא פשוט "לפני".
בדקו את עצמכם
p.CompareTo(q) החזירה -300. כשהרשימה מסודרת מהקטן אל הגדול לפי ההשוואה של המחלקה, איפה יופיע p ביחס ל-q?

לפני q. הגודל 300 לא משנה דבר; הסימן השלילי פירושו "לפני".

למה עדיף לממש IComparable<Order> ולא את IComparable הלא גנרי?

בגרסה הגנרית המהדר מוודא שמשווים רק ל-Order, ואין צורך להמיר מ-object ולבדוק את הטיפוס. לטיפוסי ערך נחסך גם ה-boxing.

חזרה לתוכן העניינים

מה קורה בתוך Sort כשהמחלקה מממשת IComparable

מתודת מיון שלא קיבלה comparer נשענת על הסדר הטבעי. כך עובדים Array.Sort, List<T>.Sort() בלי פרמטרים, SortedSet<T>, המפתחות של SortedList ושל SortedDictionary, ו-OrderBy של LINQ, שמגיע ל-CompareTo דרך Comparer<T>.Default.

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

ויש דברים שהממשק לא עושה:

  • רשימה רגילה לא שומרת על עצמה ממוינת. מה שמוסיפים אחרי Sort נכנס לסוף, עד שממיינים שוב.
  • איברים ששקולים בסדר לא נמחקים. הם נשארים, זה ליד זה.
C#
var marks = new List<int> { 4, 9, 4, 1 };
marks.Sort();
Console.WriteLine(string.Join(" ", marks) + "  count=" + marks.Count);
marks.Add(2);                 // the list does not re-sort itself
Console.WriteLine(string.Join(" ", marks));
פלט
1 4 4 9  count=4
1 4 4 9 2

מחלקה שלא מממשת IComparable, כשגם לא סופק comparer, פשוט לא ניתנת למיון, והניסיון נכשל בזמן ריצה:

C#
var tokens = new List<Token> { new Token(), new Token() };
try {
    tokens.Sort();
} catch (InvalidOperationException e) {
    Console.WriteLine(e.GetType().Name + ": " + e.Message);
    Console.WriteLine("inner: " + e.InnerException.Message);
}

class Token { }   // implements nothing
פלט
InvalidOperationException: Failed to compare two elements in the array.
inner: At least one object must implement IComparable.
Array.Sort ו-List<T>.Sort אינם מיון יציב: אין הבטחה שאיברים שקולים ישמרו את הסדר שהיה ביניהם קודם. OrderBy של LINQ כן יציב.

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

תרחיש 15: החלפת הצדדים הופכת את הכיוון
C#
var planets = new List<Planet> { new Planet(3), new Planet(11), new Planet(7), new Planet(20) };
planets.Sort();
Console.WriteLine(string.Join(" ", planets.Select(p => p.Mass)));

class Planet : IComparable<Planet> {
    public int Mass;
    public Planet(int mass) { Mass = mass; }
    // the argument is on the left, this is on the right
    public int CompareTo(Planet other) { return other.Mass.CompareTo(Mass); }
}
פלט
20 11 7 3

בנוסח הרגיל, Mass.CompareTo(other.Mass), התוצאה שלילית כש-this קל יותר, ולכן הקל ביותר יוצא ראשון. כאן הצדדים הוחלפו.

קחו this עם 20 ו-other עם 3: מחושב 3.CompareTo(20), והתוצאה שלילית. כלומר 20 "בא לפני" 3, וכך כל הרשימה מסתדרת מהכבד אל הקל.

תרחיש 16: שדה שחושב פעם אחת, בבנאי
C#
var boxes = new List<Box> { new Box(2, 3), new Box(1, 1), new Box(4, 4) };
boxes[1].W = 10;              // the box is now 10x1, but area is still 1
boxes.Sort();
Console.WriteLine(string.Join(" ", boxes.Select(b => b.W + "x" + b.H)));

class Box : IComparable<Box> {
    public int W, H;
    private int area;
    public Box(int w, int h) { W = w; H = h; area = w * h; }   // computed once
    public int CompareTo(Box other) { return area.CompareTo(other.area); }
}
פלט
10x1 2x3 4x4

ההשוואה נעשית לפי area, שחושב בבנאי ולא מתעדכן. אחרי שהקופסה השנייה שונתה ל-10x1, השדה area שלה עדיין 1.

לכן הסדר לפי area הוא 1, 6, 16: קודם 10x1, אחריה 2x3 ובסוף 4x4. מי שמחשב בראש את W*H העדכני יקבל 2x3, 10x1, 4x4, ויטעה.

טעויות נפוצות
  • מחלקה שמממשת IComparable דואגת שהרשימה תישאר ממוינת לאורך זמן. IComparable רק מגדיר איך להשוות. צריך לקרוא שוב ל-Sort אחרי כל שינוי, כמו שה-2 שנוסף לסוף הרשימה מראה.
  • Sort לפי IComparable משאיר באוסף רק ערכים ייחודיים. List<T>.Sort לא מוחק אף איבר; הכפולים נשארים במקומם.
  • המיון משווה עם < ו->, שהממשק מוסיף למחלקה. IComparable לא מגדיר אופרטורים. המיון קורא ל-CompareTo.
  • בהיעדר הוראה אחרת, המיון משווה לפי השדה הראשון שהוגדר במחלקה. המיון לא מסתכל על השדות בכלל, רק על התוצאה של CompareTo.
  • עם IComparable ההשוואה נעשית על ידי אובייקט חיצוני שמועבר למתודת המיון. זה תיאור של IComparer. עם IComparable המופעים משווים את עצמם.
בדקו את עצמכם
ב-CompareTo של Lap כתוב return other.Time.CompareTo(Time);. ברשימה זמנים 50, 12, 33, וקוראים ל-Sort(). מה הסדר?

50, 33, 12. other עומד משמאל, ולכן ההשוואה הפוכה והמיון יורד.

בבנאי של Song נשמר durationKey = Minutes * 60, ו-CompareTo משווה לפי durationKey. אחר כך משנים את Minutes של אחד השירים וממיינים. לפי איזה ערך ימוקם השיר הזה?

לפי durationKey הישן שחושב בבנאי. השינוי ב-Minutes לא נגע בשדה שההשוואה קוראת.

מה קורה ב-Sort() של List<Point> כש-Point לא מממשת שום ממשק השוואה ולא סופק comparer?

נזרקת InvalidOperationException, וה-inner exception מסביר שלפחות אחד האובייקטים צריך לממש IComparable.

חזרה לתוכן העניינים

לכתוב CompareTo נכון: מפתח שובר שוויון, חיסור שגולש, התאמה ל-Equals

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

C#
var games = new List<Fixture> {
    new Fixture("North", 3), new Fixture("East", 7), new Fixture("North", 1), new Fixture("East", 2)
};
games.Sort();
Console.WriteLine(string.Join("  ", games));

class Fixture : IComparable<Fixture> {
    public string League; public int Round;
    public Fixture(string league, int round) { League = league; Round = round; }
    public int CompareTo(Fixture other) {
        int byLeague = string.CompareOrdinal(League, other.League);   // primary key
        if (byLeague != 0) return byLeague;
        return Round.CompareTo(other.Round);                          // tie-breaker
    }
    public override string ToString() { return League + "/" + Round; }
}
פלט
East/2  East/7  North/1  North/3

שלוש טעויות חוזרות במימוש כזה:

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

כך נראית טעות החיבור בפועל. East אמורה לבוא לפני North, אבל המפתח המשני מבטל את ההכרעה:

C#
var a = new Fixture("East", 9);
var b = new Fixture("North", 1);
Console.WriteLine(a.CompareTo(b));   // East should come first, so we expect a negative value

class Fixture : IComparable<Fixture> {
    public string League; public int Round;
    public Fixture(string league, int round) { League = league; Round = round; }
    public int CompareTo(Fixture other) {
        // buggy: the two results are added instead of using the second one only on a tie
        return string.Compare(League, other.League) + Round.CompareTo(other.Round);
    }
}
פלט
0

string.Compare החזירה -1 (East לפני North), Round.CompareTo החזירה 1 (9 אחרי 1), והסכום יצא 0: המימוש טוען ששני משחקים מליגות שונות שקולים זה לזה.

חיסור שגולש. הנוסח return Value - other.Value; נראה קצר וטבעי, אבל עם מספרים קיצוניים ההפרש לא נכנס ב-int. ב-C# חשבון int הוא unchecked כברירת מחדל, ולכן לא נזרקת חריגה: התוצאה מתעטפת לצד השני של הטווח, והסימן שלה שגוי.

C#
var top = new Reading(int.MaxValue);
var low = new Reading(-5);
Console.WriteLine(top.Value > low.Value);
Console.WriteLine(top.CompareBySubtraction(low));
Console.WriteLine(top.CompareTo(low));

class Reading : IComparable<Reading> {
    public int Value;
    public Reading(int v) { Value = v; }
    public int CompareBySubtraction(Reading other) { return Value - other.Value; }   // may wrap around
    public int CompareTo(Reading other) { return Value.CompareTo(other.Value); }     // always the right sign
}
פלט
True
-2147483644
1

int.MaxValue פחות -5 היה אמור לצאת 2147483652, אבל זה מעבר לגבול העליון של int, והערך מתעטף למספר שלילי. כך מופע גדול "יוצא" קטן. באותו אופן int.MinValue פחות 1 מתעטף ל-int.MaxValue, ומופע קטן מאוד יוצא גדול.

התיקון הוא Value.CompareTo(other.Value), שמחזירה תמיד את הסימן הנכון. שימו לב שגם הגרסה השבורה מתקמפלת בלי שום הערה, כי היא מחזירה int בדיוק כמו שהחוזה דורש.

התאמה ל-Equals. הכלל: CompareTo צריכה להחזיר 0 בדיוק עבור אותם זוגות ש-Equals מחשיבה שווים. בנוסף, ההשוואה צריכה להיות רפלקסיבית (a מול עצמו נותן 0), אנטי-סימטרית (אם a לפני b, אז b אחרי a) וטרנזיטיבית (אם a לפני b ו-b לפני c, אז a לפני c). השוואה שמפרה את הכללים יכולה להכשיל מיון או להחזיר סדר שגוי.

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

תרחיש 17: SortedSet שבולע מוצרים בשקט
C#
var shelf = new SortedSet<Product> { new Product("pen", 5), new Product("cup", 5), new Product("mug", 8) };
Console.WriteLine(shelf.Count);
Console.WriteLine(shelf.Add(new Product("ink", 8)));
Console.WriteLine(string.Join(", ", shelf.Select(p => p.Name)));

class Product : IComparable<Product> {
    public string Name; public int Price;
    public Product(string name, int price) { Name = name; Price = price; }
    public int CompareTo(Product other) { return Price.CompareTo(other.Price); }   // price only
}
פלט
2
False
pen, mug

SortedSet לא שואל את Equals אם איבר כבר נמצא בו; הוא שואל את ההשוואה. pen ו-cup עולים 5, CompareTo מחזירה 0, ולכן cup נחשב כפול ולא נכנס. אותו דבר קורה ל-ink מול mug.

אין חריגה ואין שגיאת הידור: Add פשוט מחזירה false, והמוצר נעלם, אף שלפי Equals ולפי השכל הישר אלה מוצרים שונים. זו בדיוק הסיבה לדרישה ש-CompareTo תתאים ל-Equals.

התיקון: להוסיף מפתח משני, למשל את Name, שמכריע כשהמחירים שווים.

טעויות נפוצות
  • return X - other.X; הוא מימוש בטוח לכל ערך. בקצוות הטווח החיסור גולש והסימן מתהפך, כמו שראיתם עם int.MaxValue מול -5.
  • גלישה בחיסור תזרוק OverflowException. ב-C# חשבון int הוא unchecked כברירת מחדל, ולכן הערך פשוט מתעטף בלי שום הודעה.
  • SortedSet מחליט אם איבר כבר קיים לפי Equals. הוא מחליט לפי CompareTo, או לפי ה-comparer שקיבל.
  • המהדר מסרב לקבל CompareTo שסותרת את Equals. המהדר לא מנתח את הלוגיקה הזו. הסתירה תתגלה רק בזמן ריצה.
  • כש-CompareTo ו-Equals סותרות, Add של SortedSet זורקת InvalidOperationException. לא נזרק דבר. Add מחזירה false והאיבר פשוט לא נוסף.
בדקו את עצמכם
Movie צריכה להיות ממוינת לפי Year, ובשנה זהה לפי Title. תארו במילים את גוף CompareTo.

משווים קודם את Year (עם Year.CompareTo(other.Year)), ואם התוצאה שונה מ-0 מחזירים אותה. אחרת מכריעים לפי Title מול other.Title ומחזירים את מה שההשוואה הזו נתנה.

הציונים אצלכם תמיד בין 0 ל-100, ולכן return Score - other.Score; לא יגלוש בפועל. למה בכל זאת עדיף Score.CompareTo(other.Score)?

כי החיסור הוא תבנית שנשברת ברגע שהטווח משתנה או שהקוד מועתק למקום אחר, ואילו CompareTo נכונה לכל ערך ולא עולה יותר.

ב-SortedSet<City> ההשוואה היא לפי Country בלבד. מוסיפים את Haifa ואחריה את Eilat, שתיהן באותה מדינה. כמה ערים יהיו בקבוצה?

אחת. Eilat מקבלת 0 מול Haifa, נחשבת כפולה, ו-Add מחזירה false.

חזרה לתוכן העניינים

המקבילה ב-Java: Comparable מול Comparator

השם IComparable שייך ל-.NET בלבד. ב-Java הממשק המקביל הוא java.lang.Comparable<T>, והמתודה שלו היא int compareTo(T o), עם c קטנה. גם הוא מגדיר סדר טבעי, ועליו נשענים Collections.sort, Arrays.sort, TreeSet ו-TreeMap.

את התפקיד של IComparer ממלא java.util.Comparator<T> עם int compare(T a, T b): השוואה חיצונית לסדר חלופי. את רובם בונים היום בשורה אחת עם Comparator.comparing(...).

Java
import java.util.*;

class Runner implements Comparable<Runner> {
    String name; int seconds;
    Runner(String n, int s) { name = n; seconds = s; }
    public int compareTo(Runner o) { return Integer.compare(seconds, o.seconds); }   // natural order: time
    public String toString() { return name + "(" + seconds + ")"; }
}

public class RaceDemo {
    public static void main(String[] args) {
        List<Runner> race = new ArrayList<>(Arrays.asList(
                new Runner("Omer", 340), new Runner("Gal", 298), new Runner("Rina", 315)));
        Collections.sort(race);                              // uses compareTo
        System.out.println(race);
        race.sort(Comparator.comparing(r -> r.name));        // a one-off order by name
        System.out.println(race);
        System.out.println(new TreeSet<>(race).first());     // TreeSet uses the natural order again
    }
}
פלט
[Gal(298), Rina(315), Omer(340)]
[Gal(298), Omer(340), Rina(315)]
Gal(298)

הסדר הטבעי לפי זמן נשאר בתוך המחלקה, והמיון לפי שם קיבל Comparator חד-פעמי בלי שינוי אחד ב-Runner. Integer.compare היא המקבילה של Value.CompareTo(other.Value) ב-C#, ומונעת את אותה גלישה של חיסור.

נקודה.NETJava
סדר טבעיIComparable<T> עם CompareToComparable<T> עם compareTo
השוואה חיצוניתIComparer<T> עם CompareComparator<T> עם compare
השוואה ל-nullכל מופע גדול מ-null: מוחזר מספר חיוביהחוזה קובע ש-compareTo(null) צריכה לזרוק NullPointerException
מיון של מחלקה שאינה ברת השוואהInvalidOperationExceptionClassCastException, למשל ב-Arrays.sort(Object[]) או בהוספה ל-TreeSet
יציבות מיון האובייקטיםArray.Sort ו-List<T>.Sort לא יציבים (OrderBy כן)מיון האובייקטים של Java (TimSort) יציב
Java
import java.util.*;

class Crate { }   // not Comparable

public class CompareNullDemo {
    public static void main(String[] args) {
        try {
            Integer.valueOf(4).compareTo(null);
        } catch (NullPointerException e) {
            System.out.println("compareTo(null): " + e.getClass().getSimpleName());
        }
        try {
            new TreeSet<Crate>().add(new Crate());
        } catch (ClassCastException e) {
            System.out.println(e.getMessage());
        }
    }
}
פלט
compareTo(null): NullPointerException
Crate cannot be cast to java.lang.Comparable

ההודעה של ClassCastException כאן היא של Java 8. בגרסאות חדשות יותר הנוסח שלה ארוך יותר, אבל החריגה עצמה זהה.

טעויות נפוצות
  • גם ב-Java מחלקה מממשת IComparable כדי להגדיר סדר. ב-Java הממשק נקרא Comparable, והמתודה compareTo באות קטנה.
  • Comparable הוא האובייקט החיצוני שמקבל שני מופעים ומשווה ביניהם. זה Comparator. את Comparable מממשת המחלקה עצמה, והמופע משווה את עצמו לאחר.
  • ב-Java, בדיוק כמו ב-.NET, השוואה ל-null מחזירה מספר חיובי. החוזה של Comparable אומר ש-compareTo(null) צריכה לזרוק NullPointerException.
בדקו את עצמכם
ב-Java, Hotel מממשת Comparable לפי מספר הכוכבים. בדוח אחד צריך את המלונות לפי עיר. האם צריך לגעת ב-compareTo?

לא. מעבירים למיון Comparator לפי עיר, למשל Comparator.comparing(h -> h.city), והסדר הטבעי לפי כוכבים נשאר כמו שהוא.

מוסיפים ל-TreeSet מופע של מחלקה שלא מממשת Comparable, בלי Comparator. מה קורה, ומה המקביל ב-.NET כשממיינים רשימה של אובייקטים כאלה?

נזרקת ClassCastException. ב-.NET, מיון של אובייקטים בלי IComparable ובלי comparer זורק InvalidOperationException.

חזרה לתוכן העניינים

סיכום

  • Singleton: מופע אחד בלבד, ונקודת גישה אחת אליו מכל מקום. הרכיבים: בנאי private, שדה static שמחזיק את המופע, מתודה static שמחזירה אותו, ומחלקה שאי אפשר לרשת ממנה (final ב-Java, sealed ב-C#).
  • אתחול רעב (eager) יוצר את המופע כבר כשהמחלקה מאותחלת, ובטיחות ה-threads מגיעה מהאתחול הסטטי עצמו. אתחול עצל (lazy) מחכה לקריאה הראשונה, וכך חוסך משאבים כשהמופע לא נחוץ.
  • לאתחול עצל שגם בטוח ל-threads יש כמה דרכים: synchronized על getInstance; בדיקה כפולה עם volatile, שבה הבדיקה החיצונית חוסכת את הנעילה והפנימית מונעת מופע שני; מחלקת holder; enum; וב-C# הטיפוס Lazy<T>.
  • יצירה בטוחה של המופע לא הופכת את המתודות שלו לבטוחות ל-threads. Singleton גם מביא איתו מצב גלובלי, תלות שלא רואים מבחוץ ובדיקות שקשה לכתוב; התרופה המקובלת היא ממשק והזרקת תלויות.
  • בנאי נקרא בשם המחלקה, אין לו טיפוס החזרה, והוא רץ בכל new. בנאי ברירת מחדל נוצר רק כשלא נכתב אף בנאי. this(...) מעביר לבנאי אחר באותה מחלקה, ו-super(...) (ב-C#: base(...)) לבנאי האב.
  • גוף הבנאי של האב רץ לפני גוף הבנאי של היורשת. כשבנאי האב קורא למתודה נדרסת: ב-Java השדות של היורשת עדיין 0 או null; ב-C# אתחולי השדות של היורשת כבר רצו; ב-C++ רצה הגרסה של המחלקה שהבנאי שלה פועל באותו רגע.
  • protected ב-Java פתוח למחלקה, לכל החבילה שלה וליורשות בכל חבילה. יורשת מחבילה אחרת ניגשת רק דרך הטיפוס שלה עצמה, ולבנאי protected רק דרך super. מחלקה ברמה העליונה לא יכולה להיות protected.
  • protected ב-C# פתוח רק למחלקה וליורשות שלה, בלי שאר ה-assembly. protected internal הוא האיחוד של שתי ההרשאות, ו-private protected הוא החיתוך שלהן.
  • בדרך כלל עדיף להשאיר את השדות private ולתת ליורשות מתודות protected, במקום לפתוח את השדות עצמם.
  • ממשק הוא חוזה: אין בו שדות מופע ואין בנאים, ומחלקה יכולה לממש כמה ממשקים שתרצה. מתודות default קיימות מ-Java 8 ומ-C# 8; ב-Java, כששתי מתודות default מתנגשות, המחלקה חייבת לדרוס, והיא יכולה לבחור גרסה עם X.super.m().
  • מחלקה אבסטרקטית יכולה להחזיק מצב, בנאי וקוד משותף, אבל כל מחלקה יורשת רק מאחת כזו.
  • בפולימורפיזם האובייקט בפועל קובע איזו גרסה תרוץ, והמהדר מרשה לקרוא רק למה שקיים בטיפוס המוצהר. העמסה (overloading) נבחרת בהידור לפי הטיפוסים המוצהרים, ודריסה נבחרת בריצה לפי האובייקט. מתודות static ושדות אינם פולימורפיים.
  • פונקציה וירטואלית נבחרת בזמן ריצה דרך ה-vtable. ב-Java זו ברירת המחדל; ב-C# צריך virtual בבסיס ו-override ביורשת, new רק מסתירה, ו-sealed override נועלת את הדריסה.
  • ב-C++ בסיס פולימורפי צריך Destructor וירטואלי, כדי שהשחרור של היורשת ירוץ; ב-Java וב-C# את הזיכרון מנהל ה-Garbage Collector.
  • CompareTo של IComparable מחזירה שלילי, 0 או חיובי, ורק הסימן קובע. זה הסדר הטבעי ש-Sort ו-SortedSet משתמשים בו; IComparer הוא השוואה חיצונית לסדר אחר.
  • מימוש נכון: מפתח ראשי, ורק בשוויון מפתח משני; X.CompareTo(other.X) במקום חיסור; ו-0 רק כש-Equals מסכימה. ב-Java המקבילות הן Comparable ו-Comparator.