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

High Level Programming

מבחנים מסכמים

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

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

חומר לימוד

מבחנים מסכמים: חזרה מרוכזת על 18 המושגים של תכנות בשפות עיליות

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

  • מונחה עצמים: Singleton, Constructor, protected, Interface, Polymorphism, Virtual function ו-IComparable.
  • ערכים, זרימה ושגיאות: By value, Recursion ו-Exception.
  • הפלטפורמה שמריצה את הקוד: Bytecode, JVM, main, Interpreter ו-JIT.
  • זמן ריצה מתקדם: Reflection, Garbage collector ו-Mutex.

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

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

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

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

Singleton: מחלקה עם מופע יחיד

מה הדפוס מבטיח ואיך בונים אותו

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

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

שתי הגדרות שגויות חוזרות במבחנים: הדפוס לא נועד לייצר כמה עותקים זהים, והוא גם לא נועד לאסור ירושה באופן כללי. מה שהוא מבטיח הוא מופע אחד בלבד.
רכיבאיך כותביםמה הוא נותן
בנאי פרטיprivate על הבנאיקוד שנמצא מחוץ למחלקה לא יכול להפעיל new ולבנות עוד אובייקט
שדה המופעשדה private staticשדה סטטי שייך למחלקה עצמה, ולכן יש ממנו עותק יחיד, ובו נשמר האובייקט
נקודת הגישהpublic static: ב-Java בדרך כלל getInstance(), וב-C# מאפיין סטטי בשם Instanceהדרך היחידה לקבל את האובייקט, ותמיד את אותו אובייקט

תוספת מומלצת היא final על המחלקה ב-Java, או sealed ב-C#. היא מבהירה לכל מי שקורא את הקוד שלמחלקה הזו לא יהיו יורשות.

אתחול רעב (Eager): בונים את האובייקט כבר בהגדרת השדה, למשל private static final Config INSTANCE = new Config();. ה-JVM יבנה אותו פעם אחת, כשהוא מאתחל את המחלקה לקראת השימוש הראשון בה.

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

אתחול עצל (Lazy): דוחים את הבנייה עד הקריאה הראשונה ל-getInstance, כדי לא לשלם על אובייקט שאולי אף אחד לא יבקש.

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

Java
public class App {
    static final class Catalog {
        private Catalog() { System.out.println("Catalog: loading 3 items"); }

        private static class Holder {                  // initialized only when first touched
            static final Catalog ONLY = new Catalog();
        }

        static Catalog getInstance() { return Holder.ONLY; }
        static String version() { return "v7"; }      // does not touch Holder
    }

    public static void main(String[] argv) {
        System.out.println("version " + Catalog.version());
        System.out.println("no catalog yet");
        Catalog x = Catalog.getInstance();
        Catalog y = Catalog.getInstance();
        System.out.println("x == y -> " + (x == y));
    }
}
פלט
version v7
no catalog yet
Catalog: loading 3 items
x == y -> true
תרחיש 1: הקטלוג נבנה רק כשמבקשים אותו

השורה הראשונה קוראת ל-version(), מתודה סטטית של Catalog שלא נוגעת ב-Holder. לכן מודפס v7, ושום קטלוג עוד לא נבנה.

גם no catalog yet מודפס לפני הבנאי, כי עד עכשיו אף שורה לא פנתה לשדה ONLY.

הקריאה הראשונה ל-getInstance() ניגשת ל-Holder.ONLY. זה השימוש הראשון ב-Holder, ה-JVM מאתחל אותה ברגע זה, והבנאי מדפיס את שורת הטעינה.

בקריאה השנייה Holder כבר מאותחלת, ולכן חוזר אותו שדה בלי בנייה נוספת. x == y משווה הפניות ומחזיר true: שני המשתנים מחזיקים את אותו אובייקט.

אילו המופע היה יושב בשדה רעב של Catalog עצמה, כבר הקריאה ל-version() הייתה מאתחלת את המחלקה ובונה אותו. זה ההבדל בין רעב לעצל.
חזרה לתוכן העניינים

כשכמה threads מבקשים את המופע יחד

הגרסה העצלה שכותבים בפעם הראשונה בודקת if (instance == null) ורק אז מפעילה new. בתוכנית עם thread אחד היא תקינה, אבל כשיש כמה threads היא נשברת.

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

בתוכנית הבאה השהיה קצרה מרחיבה את החלון בכוונה, ומחסום (CyclicBarrier) משחרר את שני ה-threads באותו רגע. החלק השני מריץ את אותו ניסוי על גרסה עם synchronized.

Java
import java.util.concurrent.CyclicBarrier;

public class App {
    static class Naive {
        private static Naive inst;
        private Naive() { System.out.println("Naive built"); }
        static Naive get() {
            if (inst == null) {
                pause();                     // a thread switch can happen right here
                inst = new Naive();
            }
            return inst;
        }
    }

    static class Locked {
        private static Locked inst;
        private Locked() { System.out.println("Locked built"); }
        static synchronized Locked get() {   // check and create run as one step
            if (inst == null) {
                pause();
                inst = new Locked();
            }
            return inst;
        }
    }

    static void pause() {
        try { Thread.sleep(100); } catch (InterruptedException e) { }
    }

    static Object first, second;
    static final CyclicBarrier gate = new CyclicBarrier(2);

    static void together() {                 // both threads leave this line at the same moment
        try { gate.await(); } catch (Exception e) { }
    }

    public static void main(String[] argv) throws Exception {
        Thread t1 = new Thread(() -> { together(); first = Naive.get(); });
        Thread t2 = new Thread(() -> { together(); second = Naive.get(); });
        t1.start(); t2.start(); t1.join(); t2.join();
        System.out.println("naive, same object: " + (first == second));

        t1 = new Thread(() -> { together(); first = Locked.get(); });
        t2 = new Thread(() -> { together(); second = Locked.get(); });
        t1.start(); t2.start(); t1.join(); t2.join();
        System.out.println("locked, same object: " + (first == second));
    }
}
פלט
Naive built
Naive built
naive, same object: false
Locked built
locked, same object: true
תרחיש 2: שני בנאים בגרסה התמימה

שני ה-threads יוצאים מהמחסום יחד ונכנסים ל-Naive.get(). כל אחד בודק את השדה ומוצא null, כי איש עוד לא כתב אליו.

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

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

ב-Locked.get() המילה synchronized הופכת את הבדיקה ואת הבנייה לצעד אחד. ה-thread השני ממתין עד שהראשון יוצא מהמתודה, ואז מוצא בשדה אובייקט קיים ומחזיר אותו.

הניסוי עצמו מראה למה שלושה תיקונים מתבקשים לא היו עוזרים:

  • ל-Naive כבר יש בנאי private, ובכל זאת נבנו שני אובייקטים. את ה-new מפעילה get() עצמה, מתוך המחלקה, וההגבלה של private חלה רק על קוד מבחוץ.
  • גם get() כבר static, וזה לא שינה כלום: המילה מצמידה את המתודה למחלקה, ואינה קובעת דבר לגבי כמה threads נכנסים אליה בבת אחת.
  • אילו היינו מסמנים את inst כ-volatile, שני ה-threads עדיין היו נרדמים אחרי הבדיקה ובונים. volatile מבטיח שקריאה של השדה תראה את הכתיבה האחרונה אליו, לא שהבדיקה וה-new יתבצעו בלי הפרעה באמצע.

הדרכים שכן עובדות:

דרךעצלה?מה לזכור
מתודה synchronized, או בלוק synchronized סביב הבדיקה וה-new גם יחדכןנכונה וקלה לכתיבה, אבל כל קריאה משלמת על נעילה, גם הרבה אחרי שהבנייה הסתיימה
Double-checked lockingכןבודקים פעם אחת מחוץ לנעילה, ורק מי שמצא null נכנס אליה ובודק שוב. ב-Java, מגרסה 5, השדה מסומן volatile: בלי המילה הזו thread אחר יכול לקבל את ההפניה לפני שהבנאי סיים למלא את השדות
שדה static final רעבלאהבנייה קורית באתחול המחלקה, שה-JVM מריץ פעם אחת
Holderכןאת ההגנה נותן אתחול המחלקה המקוננת, ואתם לא כותבים נעילה
enum עם קבוע יחידלאכותבים enum Singleton { INSTANCE; }. זה המימוש ש-Effective Java מציג כמועדף
ב-C#: Lazy<T> או lockכןLazy<T> מטפל לבד בכמה threads, בלי הגדרה נוספת; החלופה הידנית היא lock ובדיקה כפולה
Java
final class Cache {
    private static volatile Cache inst;              // volatile is required here (Java 5+)
    private Cache() { System.out.println("Cache built"); }

    static Cache get() {
        Cache local = inst;
        if (local == null) {                         // 1st check: no lock on the fast path
            synchronized (Cache.class) {
                local = inst;
                if (local == null) {                 // 2nd check: inside the lock
                    inst = local = new Cache();
                }
            }
        }
        return local;
    }
}

enum Clock {
    INSTANCE;                                        // the JVM guarantees a single constant
    long ticks;
}

public class App {
    public static void main(String[] argv) {
        System.out.println(Cache.get() == Cache.get());
        Clock.INSTANCE.ticks = 5;
        System.out.println(Clock.INSTANCE.ticks + " " + (Clock.INSTANCE == Clock.valueOf("INSTANCE")));
    }
}
פלט
Cache built
true
5 true
C#
Console.WriteLine("before first use");
var a = Settings.Instance;
var b = Settings.Instance;
Console.WriteLine(ReferenceEquals(a, b));

sealed class Settings {
    private static readonly Lazy<Settings> lazy = new Lazy<Settings>(() => new Settings());  // thread-safe by default
    public static Settings Instance => lazy.Value;
    private Settings() { Console.WriteLine("Settings built"); }
}
פלט
before first use
Settings built
True
מופע שנבנה בבטחה הוא עדיין לא אובייקט בטוח. אם ל-Singleton יש מצב שמשתנה, כמו המונה ticks שלמעלה, כל גישה אליו מכמה threads צריכה סנכרון משלה (lock, synchronized או Mutex). הבטיחות של רגע הבנייה לא עוברת למתודות.
חזרה לתוכן העניינים

מה עוקף את המופע היחיד, ומה הדפוס עולה

גם Singleton שכתוב היטב אפשר לעקוף בארבע דרכים, ולכל אחת יש תשובה:

עקיפהמה קורהההגנה
Reflectionקוד שקורא ל-setAccessible(true) מסיר את החסימה מהבנאי הפרטי, ואז newInstance בונה דרכו עוד אובייקטהבנאי זוכר שכבר רץ, ובפעם השנייה זורק חריגה. גרסת enum אינה פגיעה מלכתחילה
Serializationשחזור מקובץ מייצר אובייקט טרי במקום להחזיר את הקייםreadResolve שמחזירה את INSTANCE; enum מקבל את זה בלי קוד
Cloningclone() מעתיק את האובייקטהמחלקה לא מצהירה implements Cloneable
כמה ClassLoaderכל ClassLoader מחזיק עותק משלו של המחלקה ושל השדות הסטטיים שלה, כך ששני טוענים נותנים שני מופעיםלזכור שב-Java הייחוד מובטח רק בתוך טוען אחד
Java
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class App {
    static final class Registry {
        private static final Registry ONE = new Registry();
        private Registry() { }
        static Registry get() { return ONE; }
    }

    static final class GuardedRegistry {
        private static boolean made;
        private static final GuardedRegistry ONE = new GuardedRegistry();
        private GuardedRegistry() {
            if (made) throw new IllegalStateException("second instance refused");
            made = true;
        }
    }

    enum Region { ONLY }

    public static void main(String[] argv) throws Exception {
        Constructor<Registry> c = Registry.class.getDeclaredConstructor();
        c.setAccessible(true);                       // opens the private constructor
        Registry extra = c.newInstance();
        System.out.println("plain: extra == get() -> " + (extra == Registry.get()));

        Constructor<GuardedRegistry> g = GuardedRegistry.class.getDeclaredConstructor();
        g.setAccessible(true);
        try { g.newInstance(); }
        catch (InvocationTargetException e) { System.out.println("guarded: " + e.getCause().getMessage()); }

        Constructor<?> r = Region.class.getDeclaredConstructors()[0];
        r.setAccessible(true);
        try { r.newInstance("SECOND", 1); }
        catch (IllegalArgumentException e) { System.out.println("enum: " + e.getMessage()); }
    }
}
פלט
plain: extra == get() -> false
guarded: second instance refused
enum: Cannot reflectively create enum objects

בקטע הראשון ההשוואה מחזירה false: לצד ONE נולד אובייקט שני. בקטע השני הבנאי מזהה שכבר יש מופע וזורק, ו-Reflection מחזירה את החריגה עטופה ב-InvocationTargetException. בקטע השלישי ה-JVM מסרב לבנות קבוע enum נוסף.

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

ב-C# עולה השאלה למה לא פשוט static class. התשובה: מחלקה סטטית היא אוסף של איברים, לא אובייקט. אילו Settings מהדוגמה של Lazy<T> הייתה מממשת ממשק, אפשר היה להציב אותה במשתנה מטיפוס הממשק, להעביר אותה למתודה כארגומנט ולבנות אותה רק כשמבקשים; static class לא מאפשרת אף אחד מהשלושה.

למה לא להשתמש בדפוס בכל מקום? נניח ש-Invoice קוראת בתוך הקוד שלה ל-TaxTable.getInstance(). מי שקורא את הבנאי של Invoice לא יודע על התלות, כל הבדיקות חולקות את אותו מצב גלובלי, ואין דרך פשוטה להעביר לבדיקה טבלת מס מדומה (Mock).

הפתרון המקובל: עדיין מופע אחד, אבל אף מחלקה לא שולפת אותו בעצמה. מכל של הזרקת תלויות (Dependency Injection) יוצר את TaxTable ומעביר אותה ל-Invoice דרך הבנאי, כך שהתלות גלויה ובבדיקה אפשר להעביר משהו אחר.

טעויות נפוצות
  • private על הבנאי מבטיח ששני threads לא יבנו שני אובייקטים. הוא חוסם רק new שנכתב מחוץ למחלקה. התחרות מתרחשת בתוך getInstance, ושם הבנאי נגיש.
  • ה-JVM מסנכרן לבד כל קריאה למתודה static. static קובע שייכות למחלקה. סנכרון מקבלים רק עם synchronized או עם נעילה מפורשת.
  • volatile על השדה מספיק, גם כשבודקים null פעם אחת ולא נועלים בכלל. volatile פותר את נראות הערך, לא את האטומיות של צמד הפעולות בדיקה ובנייה.
  • כל thread מקבל מופע פרטי במחסנית שלו, ולכן אין התנגשות. אובייקטים נמצאים בערמה המשותפת. כל ה-threads רואים את אותו שדה ואת אותו אובייקט, ובגלל זה בדיוק צריך סנכרון.
  • השפה נועלת בעצמה כל קריאה וכתיבה של שדה סטטי. אין נעילה כזו. ה-JVM מגן רק על האתחול הסטטי של המחלקה, שקורה פעם אחת.
  • final על המחלקה הוא מה שמבטיח מופע יחיד. final רק אוסר ירושה. את הייחוד נותנים הבנאי הפרטי והשדה הסטטי.
בדקו את עצמכם
השדה private static final Metrics M = new Metrics(); נכתב בלי שום synchronized. האם שני threads שפונים למחלקה לראשונה עלולים לבנות שני אובייקטים?

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

שרת קורא ל-getInstance מיליוני פעמים בשנייה. למה Holder עדיף כאן על getInstance שמסומנת synchronized?

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

איזה מימוש עומד גם מול Reflection וגם מול Serialization בלי לכתוב קוד הגנה?

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

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

Constructor: הבנאי

מה הבנאי עושה, ומה לא

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

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

משימהמי עושה אותה
לתת ערכי פתיחה לשדות של אובייקט חדשהבנאי
להקצות זיכרון לאובייקטnew, תמיד, גם כשהבנאי ריק לגמרי
לרוץ שוב בכל קריאה למתודהאף אחד: הבנאי רץ פעם אחת לכל אובייקט
לשחרר משאבים לפני שהאובייקט נעלםDispose, try-with-resources, או finalizer
לאתחל את השדות הסטטיים של המחלקהבלוק static ב-Java, בנאי סטטי ב-C#

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

Java
class Lamp {
    String state = "off";
    void Lamp() {                       // has a return type, so it is an ordinary method
        state = "on";
        System.out.println("void Lamp() ran");
    }
}

public class App {
    public static void main(String[] argv) {
        Lamp l = new Lamp();            // the hidden default constructor runs, not the method
        System.out.println(l.state);
        l.Lamp();                       // only an explicit call runs it
        System.out.println(l.state);
    }
}
פלט
off
void Lamp() ran
on

new Lamp() הפעיל את בנאי ברירת המחדל שהמהדר הוסיף, ולכן state נשאר off. רק הקריאה המפורשת l.Lamp() שינתה אותו.

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

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

Java
class Sensor {
    String id;
    int reading;
    boolean active;

    Sensor() { }                                   // leaves the language defaults
    Sensor(String id, int reading) {               // gives values that make sense
        this.id = id;
        this.reading = reading;
        this.active = true;
    }

    public String toString() { return id + " " + reading + " " + active; }
}

public class App {
    public static void main(String[] argv) {
        System.out.println(new Sensor());
        Sensor north = new Sensor("north", 12);
        Sensor south = new Sensor("south", 7);
        System.out.println(north + " / " + south);
        System.out.println(north == south);
    }
}
פלט
null 0 false
north 12 true / south 7 true
false

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

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

הבנאי שהמהדר מוסיף, והעמסת בנאים

כתבו class Box { int size; } בלי שום בנאי, ו-new Box() עדיין יתקמפל: המהדר הוסיף בשקט בנאי ריק. ההרשאה שהוא מקבל תלויה בשפה. ב-Java היא כמו של המחלקה עצמה, וב-C# היא public, חוץ ממחלקה אבסטרקטית, שבה הבנאי הזה protected.

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

תרחיש 3: המושב שלא נבחר
Java
class Ticket {
    int seat;
    Ticket(int seat) { this.seat = seat; }
}

public class App {
    public static void main(String[] argv) {
        Ticket t = new Ticket();
    }
}
פלט
App.java:8: error: constructor Ticket in class Ticket cannot be applied to given types;
        Ticket t = new Ticket();
                   ^
  required: int
  found: no arguments
  reason: actual and formal argument lists differ in length
1 error

ל-Ticket יש בנאי אחד, שמקבל מספר מושב. בגללו המהדר לא הוסיף בנאי בלי פרמטרים.

new Ticket() מחפש בנאי ריק, לא מוצא, והקומפילציה נעצרת. התוכנית לא רצה בכלל, ולכן אין כאן אובייקט עם seat שערכו 0 וגם לא חריגה בזמן ריצה.

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

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

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

שימו לב גם לשרשור: שני הבנאים הקצרים לא חוזרים על ההשמות, אלא מעבירים את העבודה לבנאי המלא עם this(...). ב-Java הקריאה הזו חייבת לעמוד בשורה הראשונה של הגוף; ב-C# כותבים אותה אחרי החתימה, בצורה : this(...).

Java
class Ticket {
    final int seat;
    final String zone;

    Ticket(int seat, String zone) {
        this.seat = seat;
        this.zone = zone;
        System.out.println("full constructor: " + seat + "/" + zone);
    }
    Ticket(int seat) { this(seat, "general"); }    // must be the first statement
    Ticket() { this(0); }
}

public class App {
    public static void main(String[] argv) {
        new Ticket();
        new Ticket(14);
        new Ticket(3, "vip");
    }
}
פלט
full constructor: 0/general
full constructor: 14/general
full constructor: 3/vip

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

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

בנאים לאורך שרשרת ירושה

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

JavaC#
הקריאה לבנאי האבsuper(...) כפקודה הראשונה בגוף: base(...) אחרי החתימה
אם לא כתבתם כלוםהמהדר מוסיף super() ריקהמהדר מוסיף base() ריק
קריאה לבנאי אחר באותה מחלקהthis(...): this(...)
מגדירים שאסור לשים על בנאיabstract, static, final, synchronizedvirtual

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

Java
class Device {
    Device(String kind) { }
}
class Tablet extends Device {
    Tablet() { System.out.println("Tablet()"); }
}
פלט
Tablet.java:5: error: constructor Device in class Device cannot be applied to given types;
    Tablet() { System.out.println("Tablet()"); }
             ^
  required: String
  found: no arguments
  reason: actual and formal argument lists differ in length
1 error

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

תרחיש 4: שלושה דורות של מכשירים
Java
class Device {
    Device(String kind) { System.out.println("Device(" + kind + ")"); }
}
class Phone extends Device {
    Phone() {
        super("phone");                  // Device has no no-arg constructor
        System.out.println("Phone()");
    }
}
class SmartPhone extends Phone {
    SmartPhone() {                       // compiler inserts super() here
        System.out.println("SmartPhone()");
    }
}

public class App {
    public static void main(String[] argv) { new SmartPhone(); }
}
פלט
Device(phone)
Phone()
SmartPhone()

new SmartPhone() נכנס לבנאי של SmartPhone. לא כתוב בו super, ולכן הפקודה הראשונה שלו בפועל היא super() שהמהדר הוסיף, כלומר הבנאי של Phone.

הבנאי של Phone קורא במפורש ל-super("phone"), ואין לו ברירה: ל-Device יש רק בנאי שמקבל מחרוזת. Device רץ ראשון ומדפיס.

רק אחר כך ממשיך הגוף של Phone, ובסוף הגוף של SmartPhone. סדר ההדפסה הוא מלמעלה למטה.

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

Java
class Locked {
    private Locked() { }
}
class Key extends Locked { }
פלט
Key.java:4: error: Locked() has private access in Locked
class Key extends Locked { }
^
1 error

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

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

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

Java ו-C# בונות אובייקט של יורשת בסדר שונה, וההבדל קובע מה מתודה רואה באמצע הבנייה.

שלבJavaC#
ראשוןבנאי האב, כולל אתחולי השדות של האבאתחולי השדות של היורשת
שניאתחולי השדות של היורשת, כמו String label = "OK", לפי סדר הכתיבהאתחולי השדות של האב, ואחריהם גוף הבנאי של האב
שלישישאר גוף הבנאי של היורשתגוף הבנאי של היורשת

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

תרחיש 5: כפתור שעוד לא קיבל תווית
Java
class Widget {
    Widget() { System.out.println("Widget ctor sees: " + render()); }
    String render() { return "plain widget"; }
}

class Button extends Widget {
    String label = "OK";
    boolean enabled = true;

    Button() { System.out.println("Button ctor sees: label=" + label + " enabled=" + enabled); }

    @Override
    String render() { return "label=" + label + " enabled=" + enabled; }
}

public class App {
    public static void main(String[] argv) { new Button(); }
}
פלט
Widget ctor sees: label=null enabled=false
Button ctor sees: label=OK enabled=true

new Button() מתחיל בבנאי של Widget, דרך ה-super() שהמהדר הוסיף, והבנאי הזה קורא ל-render().

האובייקט שבבנייה הוא Button, ולכן רצה הגרסה הנדרסת של Button. אבל האתחולים label = "OK" ו-enabled = true עוד לא בוצעו, כי ב-Java הם רצים רק אחרי שבנאי האב חוזר, והמתודה רואה null ו-false.

בנאי האב מסתיים, השדות מקבלים את הערכים שלהם, והגוף של Button כבר מדפיס OK ו-true.

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

C#
new Button();

class Widget {
    int w = Trace.Log("1 Widget field initializer");
    public Widget() {
        Trace.Log("2 Widget ctor body, render says: " + Render());
    }
    public virtual string Render() => "plain widget";
}

class Button : Widget {
    string label = "OK";
    int b = Trace.Log("0 Button field initializer");
    public Button() { Trace.Log("3 Button ctor body, label=" + label); }
    public override string Render() => "label=" + label;
}

static class Trace {
    public static int Log(string s) { Console.WriteLine(s); return 0; }
}
פלט
0 Button field initializer
1 Widget field initializer
2 Widget ctor body, render says: label=OK
3 Button ctor body, label=OK

המספר בתחילת כל שורה מסמן את מקומה בסדר הביצוע: השדה של Button אותחל לפני כל דבר של Widget. לכן Render() הנדרסת, שנקראה מגוף הבנאי של האב, כבר ראתה label=OK. הקריאה עדיין הגיעה לגרסה של היורשת לפני שגוף הבנאי שלה רץ, בדיוק כמו ב-Java.

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

C++
#include <iostream>

struct Widget {
    Widget() { std::cout << "Widget ctor sees: " << render() << "\n"; }
    virtual ~Widget() {}
    virtual const char* render() const { return "plain widget"; }
};

struct Button : Widget {
    const char* render() const override { return "button"; }
};

int main() {
    Button b;                                    // inside Widget(), the object is still a Widget
    std::cout << "after construction: " << b.render() << "\n";
}
פלט
Widget ctor sees: plain widget
after construction: button

בתוך Widget() התקבלה הגרסה של Widget, ורק אחרי שהבנייה הושלמה render() הגיעה לגרסה של Button.

המסקנה המעשית: לא לקרוא למתודות שאפשר לדרוס מתוך בנאי. ב-Java המתודה תרוץ על אובייקט שהשדות שלו עדיין 0, null או false, גם אם בהגדרה שלהם כתוב ערך.
טעויות נפוצות
  • המהדר מוסיף בנאי ריק לכל מחלקה. רק למחלקה שאין בה אף בנאי כתוב. בנאי אחד שלכם מבטל את המתנה.
  • אם היורשת לא כותבת super, בנאי האב מדולג. הקריאה נוספת במשתמע, ובנאי האב רץ תמיד.
  • גוף היורשת רץ ראשון, ובנאי האב אחריו. הסדר הפוך: האב מסיים קודם.
  • בנאי האב יופעל רק אם יסומן virtual והיורשת תדרוס אותו. בנאים אינם וירטואליים, אינם נורשים ואינם נדרסים. ב-C# אסור אפילו לסמן בנאי virtual.
  • שני בנאים במחלקה אחת הם שגיאה, או שהמהדר בוחר ביניהם לפי הערך המוחזר. העמסת בנאים חוקית, וההתאמה נעשית לפי הארגומנטים שבקריאה.
  • כדי לקבל כמה מופעים בבת אחת מגדירים בנאי static. בנאי Java לא יכול להיות static. כמה מופעים מקבלים מכמה קריאות ל-new.
  • יורשת של מחלקה שאין לה אף בנאי נגיש, כי כולם private, תיכשל רק כשבונים ממנה מופע. המהדר עוצר כבר בהגדרה של היורשת.
בדקו את עצמכם
ל-Printer יש רק Printer(String model). המחלקה LabelPrinter extends Printer מגדירה LabelPrinter() { } ולא כותבת super. מה התוצאה?

הקוד לא מתקמפל: המהדר מכניס super() ריק, ול-Printer אין בנאי כזה. התיקון הוא לפתוח את הבנאי בקריאה כמו super("L-200").

ב-Java בנאי האב קורא למתודה נדרסת, והגרסה של היורשת מחזירה את השדה int retries = 3. מה תחזיר הקריאה בזמן הבנייה, ומה היה קורה ב-C#?

ב-Java יחזור 0, כי אתחולי השדות של היורשת רצים רק אחרי בנאי האב. ב-C# יחזור 3, כי שם אתחולי השדות של היורשת רצים לפני בנאי האב.

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

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

מה protected פותח ב-Java

ב-Java איבר protected נגיש משלושה כיוונים: מתוך המחלקה שלו, מכל מחלקה באותה חבילה (package), ומכל מחלקה יורשת, גם כשהיא בחבילה אחרת.

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

מהצר לרחבמילת מפתחמי ניגש
1privateהמחלקה עצמה
2בלי מילה (package-private)כל המחלקות בחבילה
3protectedכל החבילה, ובנוסף יורשות מכל חבילה
4publicכולם

שימו לב ש-package-private בטבלה הוא שם תיאורי, לא מילת מפתח: לרמת החבילה Java לא הקצתה מילה בכלל, ומשאירים את האיבר בלי מגדיר, כך שמגדיר בשם package לא קיים. גם internal ו-friend לא מופיעים בטבלה, כי internal לקוחה מ-C# ו-friend מ-C++, ולכן בשאלה על Java שתיהן תשובות שגויות.

שני כללי משנה חלים על יורשת שנמצאת בחבילה אחרת. את האיבר המוגן שירשה היא מקבלת רק דרך הפניה מהטיפוס שלה, כמו this.balance, ולא דרך הפניה מטיפוס האב. ובנאי protected של האב זמין לה רק דרך super(...), לא דרך new.

Java
// shop/Account.java
package shop;

public class Account {
    protected int balance = 50;
    protected Account() { }
}

// shop/Audit.java
package shop;

class Audit {                                   // same package, not a subclass
    int peek(Account a) { return a.balance; }   // allowed: protected includes the package
}

// bank/Savings.java
package bank;

import shop.Account;

public class Savings extends Account {
    int mine() { return this.balance; }              // own inherited field: allowed
    int other(Account a) { return a.balance; }       // through a parent-type reference
    static Account fresh() { return new Account(); } // protected constructor via new
}
פלט
bank\Savings.java:7: error: balance has protected access in Account
    int other(Account a) { return a.balance; }       // through a parent-type reference
                                   ^
bank\Savings.java:8: error: Account() has protected access in Account
    static Account fresh() { return new Account(); } // protected constructor via new
                                    ^
2 errors

Audit אינה יורשת, אבל היא באותה חבילה, ולכן הגישה שלה עברה בלי הערה. ב-Savings עברו הגישה דרך this וה-super() המשתמע אל הבנאי המוגן. נכשלו רק הגישה דרך הפניה מטיפוס Account וה-new הישיר.

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

Java
class Plugin {
    protected void start() { System.out.println("Plugin.start"); }
}
class WidePlugin extends Plugin {
    @Override public void start() { System.out.println("WidePlugin.start"); }  // widening: fine
}
class NarrowPlugin extends Plugin {
    @Override void start() { }                                                  // narrowing
}
פלט
Main.java:8: error: start() in NarrowPlugin cannot override start() in Plugin
    @Override void start() { }                                                  // narrowing
                   ^
  attempting to assign weaker access privileges; was protected
1 error
Java
protected class Top { }
פלט
Top.java:1: error: modifier protected not allowed here
protected class Top { }
          ^
1 error
חזרה לתוכן העניינים

protected ב-C# והשכנים שלו

ב-C# המשמעות צרה יותר: protected פותח את האיבר למחלקה עצמה ולמחלקות שיורשות ממנה, וזהו. מחלקה אחרת באותו assembly שאינה יורשת נשארת בחוץ.

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

בקוד הבא Vehicle אבסטרקטית, והבנאי שלה protected. מי יכול להפעיל אותו? רק מחלקה שיורשת ממנה, כמו Truck, דרך : base(...), ולא קוד מבחוץ.

ומתי הוא רץ? בכל new Truck(...): אובייקט של Truck מכיל גם את החלק של Vehicle, והחלק הזה, כאן השדה Plate, מקבל את ערכיו מהבנאי המוגן. לכן הטענה שהבנאי לא נקרא "כי אין מופעים של מחלקה אבסטרקטית" שגויה.

C#
var t = new Truck("12-345-67");
Console.WriteLine(t.Describe());

abstract class Vehicle {
    protected string Plate;
    protected Vehicle(string plate) {             // reachable only through : base(...)
        Plate = plate;
        Console.WriteLine("Vehicle ctor ran for " + plate);
    }
    public abstract int Wheels();
}

class Truck : Vehicle {
    public Truck(string plate) : base(plate) { }
    public override int Wheels() => 6;
    public string Describe() => Plate + " has " + Wheels() + " wheels";
}
פלט
Vehicle ctor ran for 12-345-67
12-345-67 has 6 wheels

השורה הראשונה בפלט הגיעה מהבנאי המוגן של Vehicle, והשדה Plate שהוא מילא שימש את Describe במחלקה היורשת. מבחוץ, לעומת זאת, שתי הגישות נחסמות:

C#
var v = new Vehicle("x");

abstract class Vehicle {
    protected string Plate;
    protected Vehicle(string plate) { Plate = plate; }
}

class Garage {
    public string Peek(Vehicle v) => v.Plate;      // same assembly, not a subclass
}
פלט
Program.cs(1,9): error CS0144: Cannot create an instance of the abstract type or interface 'Vehicle'
Program.cs(9,40): error CS0122: 'Vehicle.Plate' is inaccessible due to its protection level

CS0144 מונע בנייה ישירה של המחלקה האבסטרקטית. CS0122 חוסם את Garage, אף שהיא יושבת באותו assembly: היא לא יורשת, ו-protected של C# לא כולל את ה-assembly.

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

מתי protected עושה נזק

תארו לכם ספרייה עם מחלקת בסיס Report ששומרת את השורות שלה בשדה protected List<String> rows. עשרות יורשות, חלקן בחבילות של צוותים אחרים, קוראות וכותבות לשדה הזה ישירות.

יום אחד מחליטים לשמור את השורות במבנה אחר, וכל יורשת שנגעה ב-rows מפסיקה להתקמפל: פרט מימוש של הבסיס הפך בפועל לחלק מה-API שלו. זה הנזק של שדה protected. הוא פותח את הפנים של המחלקה לכל יורשת, וב-Java גם לכל מחלקה באותה חבילה, ופוגע בהסתרת המידע (Encapsulation).

המתכון: השדה נשאר private, והבסיס מציע ליורשות מתודות protected רק היכן שהן באמת צריכות, למשל protected void addRow(String r). ושם protected נמצא במקומו הטבעי: באיברים שנועדו ליורשות, כמו השלבים שמתודת תבנית (template method) משאירה להן להשלים.

שלושה מסיחים חוזרים סביב protected, וכל אחד מייחס לו תכונה של משהו אחר: חסימה של היורשות (זה private), פתיחה לכל הפרויקט (זה public), וחובה לממש את השדה מחדש כאילו הוא "וירטואלי" (הרשאת גישה לא קשורה לדריסה).
טעויות נפוצות
  • ב-Java protected פתוח ליורשות בלבד. בנוסף ליורשות, כל מחלקה באותה חבילה ניגשת אליו.
  • ב-C# protected פתוח לכל ה-assembly. זו ההגדרה של internal. protected הוא המחלקה והיורשות שלה בלבד.
  • ב-C# protected שקול ל-private. private סוגר גם בפני היורשות, ו-protected פותח להן.
  • בנאי protected של מחלקה אבסטרקטית לא רץ אף פעם, כי אין ממנה מופעים. הוא רץ בכל בנייה של יורשת, דרך base(...).
  • שדה protected מחייב כל יורשת לממש אותו מחדש. הרשאת גישה ודריסה הם שני נושאים נפרדים לגמרי.
בדקו את עצמכם
ב-Java המחלקות Invoice ו-Ledger נמצאות באותה חבילה, ו-Invoice אינה יורשת. מותר לה לקרוא שדה protected של Ledger?

כן. ב-Java ההרשאה protected כוללת את כל החבילה, בלי קשר לירושה.

אותו מצב ב-C#: Invoice באותו assembly כמו Ledger, בלי ירושה. האם הקריאה תעבור, ואם לא, מה יאפשר אותה?

לא תעבור, כי ב-C# protected פותח רק ליורשות. internal או protected internal היו מאפשרים אותה.

יורשת בחבילה אחרת מקבלת פרמטר מטיפוס האב וקוראת דרכו לשדה protected. מה יקרה?

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

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

Interface: ממשק

ממשק הוא חוזה

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

ב-Java כותבים interface Exporter { String export(String data); }, ומחלקה מצטרפת עם implements. ב-C# כותבים interface IExporter { string Export(string data); }, ומחלקה מצטרפת עם נקודתיים. האות I בתחילת השם ב-C# היא מוסכמה, לא חובה.

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

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

CsvExporter יכולה לרשת ממחלקת אב אחת בלבד, אבל לצד Exporter היא רשאית להצהיר באותה שורת implements גם על Comparable, Runnable ועוד. אין תנאי קדם: הממשקים לא צריכים אב משותף, והמחלקה לא צריכה להיות אבסטרקטית.

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

Java
interface Exporter {
    String export(String data);
    int priority();
}

class CsvExporter implements Exporter {
    String export(String data) { return data.replace(' ', ','); }   // no public, no priority()
}
פלט
CsvExporter.java:6: error: CsvExporter is not abstract and does not override abstract method priority() in Exporter
class CsvExporter implements Exporter {
^
CsvExporter.java:7: error: export(String) in CsvExporter cannot implement export(String) in Exporter
    String export(String data) { return data.replace(' ', ','); }   // no public, no priority()
           ^
  attempting to assign weaker access privileges; was public
2 errors

שתי שגיאות בקובץ אחד: priority() לא מומשה בכלל, ו-export מומשה בלי public, כלומר בהרשאה צרה ממה שהחוזה מבטיח.

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

Java
interface Exporter {
    String export(String data);
    int priority();
}

abstract class TextExporter implements Exporter {        // declared abstract: may leave priority() open
    public String export(String data) { return "[" + data + "]"; }
}

class LogExporter extends TextExporter {                 // the concrete subclass completes the contract
    public int priority() { return 2; }
}

public class App {
    public static void main(String[] argv) {
        Exporter e = new LogExporter();
        System.out.println(e.export("disk full") + " p=" + e.priority());
    }
}
פלט
[disk full] p=2

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

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

קבועים, default ו-static בתוך ממשק

ב-Thermostat שבתרחיש הבא כתוב int MAX_C = 30; בלי שום מגדיר. למרות המראה, זה לא שדה שכל תרמוסטט מחזיק לעצמו: Java מתייחסת אליו כ-public static final, ערך אחד לכל התוכנית, שאי אפשר לשנות.

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

מסיח נפוץ טוען שהסיבה היא שממשק "לא נטען לזיכרון". זו לא הסיבה: ה-JVM טוען ממשק כמו כל מחלקה, למשל כשנטענת Hall שמממשת אותו. ואת MAX_C עצמו, קבוע שערכו ידוע בזמן קומפילציה, javac אפילו מעתיק ישירות לתוך הקוד שקורא אותו, כך שהקריאה לא צריכה את Thermostat בזמן ריצה.

תוספתגרסהמה היא מאפשרת
מתודת defaultJava 8גוף בתוך הממשק. כך מוסיפים מתודה לממשק קיים בלי לשבור את המחלקות שכבר מממשות אותו, ומי שרוצה התנהגות אחרת דורסת
מתודת staticJava 8גוף עם המילה static. היא לא נורשת, וקוראים לה רק דרך שם הממשק, לא דרך המחלקה המממשת ולא דרך מופע
מתודת privateJava 9קוד עזר פנימי שמתודות הממשק משתפות
חבר ממשק עם מימוש (default interface member)C# 8גוף בתוך הממשק, שנגיש רק דרך הפניה מטיפוס הממשק
תרחיש 6: תרמוסטט עם קבוע, default ו-static
Java
interface Thermostat {
    int MAX_C = 30;                                   // really public static final
    int read();                                       // abstract: every class must supply it
    default String report() {                         // Java 8: body inside the interface
        return "now " + read() + "C, max " + MAX_C;
    }
    static int toF(int c) { return c * 9 / 5 + 32; }  // Java 8: called through the interface name
}

class Hall implements Thermostat {
    public int read() { return 21; }
}

public class App {
    public static void main(String[] argv) {
        Thermostat t = new Hall();
        System.out.println(t.report());
        System.out.println(Thermostat.toF(t.read()) + "F");
        System.out.println(Thermostat.MAX_C);
    }
}
פלט
now 21C, max 30
69F
30

Hall מימשה מתודה אחת בלבד, read(). ובכל זאת t.report() עובדת: זו מתודת default שכתובה בממשק, והיא קוראת ל-read() של Hall.

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

וכך נראה ניסיון להשתמש בשניהם בדרך הלא נכונה:

Java
interface Thermostat {
    int MAX_C = 30;
    static int toF(int c) { return c * 9 / 5 + 32; }
}

class Hall implements Thermostat { }

class Misuse {
    void run() {
        int f = Hall.toF(21);         // static interface method through the class
        Thermostat.MAX_C = 31;        // the "field" is a constant
    }
}
פלט
Misuse.java:10: error: cannot find symbol
        int f = Hall.toF(21);         // static interface method through the class
                    ^
  symbol:   method toF(int)
  location: class Hall
Misuse.java:11: error: cannot assign a value to final variable MAX_C
        Thermostat.MAX_C = 31;        // the "field" is a constant
                  ^
2 errors

המהדר לא מוצא את toF ב-Hall, כי מתודה סטטית של ממשק לא עוברת למחלקות המממשות. וההשמה ל-MAX_C נכשלת, כי השדה הוא final.

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

C#
var bot = new Bot();
IGreeter g = bot;
Console.WriteLine(g.Hello());              // through the interface type: works
// Console.WriteLine(bot.Hello());         // through the class type: CS1061

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

class Bot : IGreeter {
    public string Name() => "bot-3";
}
פלט
hello from bot-3

אבל קריאה ישירה דרך ביטוי מטיפוס המחלקה לא מתקמפלת:

C#
Console.WriteLine(new Bot().Hello());

interface IGreeter {
    string Name();
    string Hello() => "hello from " + Name();
}

class Bot : IGreeter {
    public string Name() => "bot-3";
}
פלט
Program.cs(1,29): error CS1061: 'Bot' does not contain a definition for 'Hello' and no accessible extension method 'Hello' accepting a first argument of type 'Bot' could be found (are you missing a using directive or an assembly reference?)
חזרה לתוכן העניינים

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

ממשקמחלקה אבסטרקטית
כמה אפשר לקחתכמה ממשקים שרוציםמחלקת אב אחת
שדות מופעאין, רק קבועיםיש
בנאיםאיןיש, והם רצים דרך היורשות
מתודות עם גוףdefault ו-static, מ-Java 8מותר מאז ומעולם
בנייה ישירה עם newאי אפשראי אפשר
מתאים ליכולת שגם מחלקות לא קשורות חולקותקוד ושדות שמחלקות קרובות חולקות

קחו את Drone מהחלק הבא, שצריכה גם לעוף וגם לצלם. אילו Flyer ו-Recorder היו מחלקות אבסטרקטיות, היא הייתה נאלצת לבחור אחת מהן, כי ב-Java יש מחלקת אב אחת. כשהם ממשקים, היא מצהירה על שניהם.

ובכיוון ההפוך: Car, Truck ו-Bus צריכות כולן שדה plate, בנאי שממלא אותו ומתודת describe() זהה, אבל כל אחת מחשבת tax() בדרך שלה. מחלקה אבסטרקטית Vehicle מחזיקה את המשותף פעם אחת ומשאירה את tax() מופשטת, כך שכל יורשת מוכרחת לכתוב אותה. ממשק לא יכול להחזיק את plate ואת הבנאי.

וכדי לא ליפול במסיח הפוך: ב-Vehicle כזו describe() כתובה עם גוף מלא, ובכל זאת new Vehicle() לא יתקמפל. מתודות עם מימוש מותרות במחלקה אבסטרקטית; בנייה ישירה שלה אסורה.
חזרה לתוכן העניינים

בדיקות, שילוב יכולות וממשק מקונן

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

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

Java
interface RateSource {
    double rate(String currency);
}

class LiveRates implements RateSource {             // the real one would call a remote service
    public double rate(String currency) { throw new IllegalStateException("no network in tests"); }
}

class Converter {
    private final RateSource rates;
    Converter(RateSource rates) { this.rates = rates; }   // depends on the interface only
    double toLocal(double amount, String currency) { return amount * rates.rate(currency); }
}

public class App {
    public static void main(String[] argv) {
        RateSource fake = currency -> 4.0;                // a stand-in for the unit test
        Converter c = new Converter(fake);
        System.out.println(c.toLocal(25, "EUR") == 100.0 ? "test passed" : "test failed");
    }
}
פלט
test passed

Converter לא יודע ש-fake אינו מקור שערים אמיתי. הבדיקה רצה בלי רשת, ותוצאתה ידועה מראש: 25 כפול 4.

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

Warehouse שבקוד הבא מגדירה בתוכה ממשק קטן, Rule, שמתאר בדיקה של משקל. זה ממשק מקונן (nested interface): הוא נותן לחלקים של מחלקה גדולה חוזה משותף לעבוד לפיו, ומכיוון שהוא private, קוד מחוץ ל-Warehouse לא יודע שהוא קיים.

Java
interface Flyer { String fly(); }
interface Recorder { String record(); }

class Rotor implements Flyer { public String fly() { return "rotor lifts"; } }
class Lens implements Recorder { public String record() { return "lens records"; } }

class Drone implements Flyer, Recorder {              // two contracts, no second superclass
    private final Flyer flyer = new Rotor();          // composition: the drone holds its parts
    private final Recorder recorder = new Lens();
    public String fly() { return flyer.fly(); }        // and hands each job to one of them
    public String record() { return recorder.record(); }
}

class Warehouse {
    private interface Rule { boolean allows(int weight); }   // nested, private: internal only
    private final Rule heavyShelf = w -> w <= 500;
    boolean canStore(int weight) { return heavyShelf.allows(weight); }
}

public class App {
    public static void main(String[] argv) {
        Drone d = new Drone();
        System.out.println(d.fly() + ", " + d.record());
        System.out.println(new Warehouse().canStore(620));
    }
}
פלט
rotor lifts, lens records
false

Drone עומדת בשני חוזים, ואת העבודה עצמה עושים Rotor ו-Lens שהיא מחזיקה. Rule קיים רק בתוך Warehouse, ומשקל 620 עובר את הגבול של 500, ולכן false.

ומה Rule לא משנה: אחרות עדיין יכולות לרשת מ-Warehouse, היא עצמה עדיין מוגבלת למחלקת אב אחת, ואף מתודת get או set לא נוספה לה בזכותו.

טעויות נפוצות
  • מחלקה מממשת ממשק אחד, בדיוק כמו שהיא יורשת ממחלקה אחת. המגבלה היא על מחלקות אב בלבד. מספר הממשקים לא מוגבל.
  • שדה שהוגדר בממשק שייך לכל אובייקט, ואפשר לעדכן אותו. הוא public static final: קבוע אחד ומשותף.
  • מחלקה שלא השלימה את החוזה תהפוך ל-abstract בעצמה, או שהבעיה תצוץ רק בהרצה. זו שגיאת קומפילציה, אלא אם הצהרתם abstract במפורש.
  • אפשר לעקוף את החובה בסימון המתודות החסרות private או בסימון המחלקה final. שום מגדיר לא מחליף מימוש, ו-final רק סוגר את הדרך בפני יורשות שיכלו להשלים.
  • מחלקה מממשת דורסת מתודה סטטית של הממשק. מתודה סטטית של ממשק לא נורשת, ולכן אין מה לדרוס. קוראים לה דרך שם הממשק.
  • יורשת קונקרטית רשאית לדלג על מתודת abstract שירשה, או לסמן אותה virtual במקום לממש. היא חייבת לדרוס ולכתוב גוף. ב-Java המילה virtual לא קיימת.
בדקו את עצמכם
לממשק Notifier יש 60 מחלקות מממשות, ורוצים להוסיף לו mute(). איך עושים זאת בלי לפתוח את כל 60 הקבצים?

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

מתכנת כותב בממשק Java int visits; ומצפה שלכל אובייקט יהיה מונה משלו. מה הבעיה?

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

מחלקה צריכה להיות גם ניתנת לשמירה וגם ניתנת להשוואה. למה שני ממשקים מתאימים כאן יותר משתי מחלקות אבסטרקטיות?

את מספר הממשקים שמחלקה מממשת לא מגבילים, ואילו מחלקת אב יש לה רק אחת.

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

Polymorphism: פולימורפיזם

צורה כללית אחת, מימושים רבים

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

מי מחליט איזו גרסה של process() תרוץ? לא הטיפוס Payment שכתוב בהצהרה, אלא המחלקה שממנה האובייקט נבנה ב-new. ההכרעה נדחית לרגע הקריאה עצמה, ולכן המנגנון נקרא dynamic dispatch או קישור מאוחר (late binding).

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

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

מה המהדר רואה ומה רץ בפועל

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

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

המרה כלפי מעלה, מ-Guitar ל-Instrument, קורית מעצמה. המרה כלפי מטה דורשת סוגריים מפורשים, והיא נבדקת בזמן ריצה: אם האובייקט אינו מהטיפוס המבוקש, ב-Java נזרקת ClassCastException, וב-C# נזרקת InvalidCastException.

תרחיש 7: להקה שמנגנת דרך טיפוס אחד
Java
class Instrument { String play() { return "(silence)"; } }

class Guitar extends Instrument {
    @Override String play() { return "strum"; }
    String tune() { return "tuning six strings"; }
}

class Drum extends Instrument {
    @Override String play() { return "boom"; }
}

public class App {
    static void perform(Instrument i) { System.out.println(i.play()); }   // knows only Instrument

    public static void main(String[] argv) {
        Instrument[] band = { new Drum(), new Guitar(), new Instrument() };
        for (Instrument i : band) perform(i);

        Instrument lead = new Guitar();
        System.out.println(((Guitar) lead).tune());     // explicit downcast

        Instrument beat = new Drum();
        Guitar wrong = (Guitar) beat;                   // compiles, checked at run time
    }
}
פלט
boom
strum
(silence)
tuning six strings
Exception in thread "main" java.lang.ClassCastException: Drum cannot be cast to Guitar
	at App.main(App.java:23)

perform מכירה רק את Instrument, ובכל זאת כל כלי משמיע את הצליל שלו: התוף boom, הגיטרה strum, והכלי הכללי את גרסת הבסיס. זו הדריסה בפעולה.

כלי חדש, למשל Violin, יעבוד עם perform בלי שינוי בה.

lead מוצהר כ-Instrument, ולכן כדי לקרוא ל-tune() צריך המרה מפורשת ל-Guitar. האובייקט אכן גיטרה, וההמרה מצליחה.

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

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

Java
class Instrument { String play() { return "(silence)"; } }
class Guitar extends Instrument { String tune() { return "tuning"; } }

public class App {
    public static void main(String[] argv) {
        Instrument lead = new Guitar();
        System.out.println(lead.tune());
    }
}
פלט
App.java:7: error: cannot find symbol
        System.out.println(lead.tune());
                               ^
  symbol:   method tune()
  location: variable lead of type Instrument
1 error

שימו לב לסוג הכשל: שגיאת קומפילציה. לא ClassCastException, וגם לא דילוג שקט על השורה. המהדר לא מציץ לתוך האובייקט; הוא בודק רק את הטיפוס המוצהר.

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

העמסה מול דריסה

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

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

Java
class Store {
    int size() { return 3; }
    long size() { return 3L; }      // only the return type differs
}
פלט
Store.java:3: error: method size() is already defined in class Store
    long size() { return 3L; }      // only the return type differs
         ^
1 error
תרחיש 8: חשבונית שהוצהרה כמסמך
Java
class Document { String title() { return "untitled document"; } }
class Invoice extends Document {
    @Override String title() { return "invoice #88"; }
}

public class App {
    static String send(Document d) { return "send(Document) got " + d.title(); }
    static String send(Invoice i)  { return "send(Invoice) got " + i.title(); }

    public static void main(String[] argv) {
        Document d = new Invoice();
        System.out.println(send(d));              // overload: picked by the declared type
        System.out.println(send((Invoice) d));
    }
}
פלט
send(Document) got invoice #88
send(Invoice) got invoice #88

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

בתוך send(Document) הקריאה d.title() היא דריסה, ולכן היא מגיעה דווקא לגרסה של Invoice: invoice #88.

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

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

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

Java
class Parent {
    String tag = "Parent field";
    static String kind() { return "Parent static"; }
    String who() { return "Parent method"; }
}

class Child extends Parent {
    String tag = "Child field";                       // hides, does not override
    static String kind() { return "Child static"; }   // hides, does not override
    @Override String who() { return "Child method"; }
}

public class App {
    public static void main(String[] argv) {
        Parent ref = new Child();
        System.out.println(ref.tag);
        System.out.println(ref.kind());
        System.out.println(ref.who());
    }
}
פלט
Parent field
Parent static
Child method

רק who(), מתודת מופע שנדרסה, הגיעה לגרסה של Child. השדה והמתודה הסטטית נבחרו לפי Parent.

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

פולימורפיזם ועקרון פתוח/סגור

בקוד הבא Checkout.total מקבלת Discount ולא יודעת איזו הנחה בדיוק הגיעה אליה. לכן אפשר להעביר לה כל מימוש, גם כזה שייכתב בעוד שנה, ולהחליף הנחה אחת באחרת בלי לגעת בה.

לתכונה הזו יש שם בעיצוב תוכנה: עקרון פתוח/סגור (Open-Closed Principle). Checkout פתוחה להרחבה, כי הנחות חדשות נכנסות בלי בעיה, וסגורה לשינוי, כי אף אחד לא פותח את הקוד שלה לעריכה. את ההרחבה מספקת מחלקה חדשה שמממשת את Discount.

Java
interface Discount { double apply(double price); }

class NoDiscount implements Discount { public double apply(double p) { return p; } }
class HalfPrice  implements Discount { public double apply(double p) { return p / 2; } }
// added later, without touching Checkout:
class MinusTen   implements Discount { public double apply(double p) { return p - 10; } }

class Checkout {
    static double total(double price, Discount d) { return d.apply(price); }   // never changes
}

public class App {
    public static void main(String[] argv) {
        Discount[] all = { new NoDiscount(), new HalfPrice(), new MinusTen() };
        for (Discount d : all) System.out.println(d.getClass().getSimpleName() + " -> " + Checkout.total(80, d));
    }
}
פלט
NoDiscount -> 80.0
HalfPrice -> 40.0
MinusTen -> 70.0

MinusTen נוספה אחרונה, ו-Checkout.total לא השתנתה בשום תו.

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

טעויות נפוצות
  • הטיפוס שבהצהרת המשתנה קובע איזו גרסה נדרסת תתבצע. בדריסה מחליט האובייקט בפועל. הטיפוס המוצהר מחליט רק מה מותר לכתוב.
  • המהדר יזהה שהאובייקט הוא Guitar ויתיר לקרוא ל-tune(). המהדר לא יודע מה יהיה שם בזמן ריצה, ובודק רק את הטיפוס המוצהר.
  • פולימורפיזם בזמן ריצה פירושו כמה מתודות באותו שם עם פרמטרים שונים. זו העמסה, והיא נפתרת בקומפילציה. בזמן ריצה פועלת הדריסה.
  • פולימורפיזם נותן ירושה מכמה מחלקות, או גישה לשדות הפרטיים של האב. אין קשר. הוא עוסק רק בבחירת המימוש שירוץ.
  • פולימורפיזם הוא הסתרת השדות וחשיפת מתודות ציבוריות. זו ההגדרה של Encapsulation.
  • קריאה וירטואלית מהירה יותר מקריאה ישירה. היא עוברת דרך שלב עקיף, ולכן מה שהיא נותנת הוא גמישות, לא מהירות.
בדקו את עצמכם
מודול משלוחים בוחר בין דואר רשום לשליח עם switch על שדה סוג. איך מוסיפים איסוף עצמי ברוח עקרון פתוח/סגור?

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

Number n = Integer.valueOf(7);, ויש שתי העמסות: log(Number) ו-log(Integer). איזו מהן נבחרת ב-log(n)?

log(Number). העמסה נבחרת בקומפילציה לפי הטיפוס המוצהר של n, לא לפי האובייקט שבתוכו.

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

Virtual function: פונקציה וירטואלית

מה הופך מתודה לוירטואלית

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

בלי המנגנון הזה לא היה פולימורפיזם: הלולאה כתובה מול Alarm, ובכל זאת מגיעה לקוד של LoudAlarm ושל SirenAlarm.

מאחורי הקלעים, ברוב המימושים, כל מחלקה מקבלת טבלה (vtable) שרשומה בה, לכל מתודה וירטואלית, הכתובת של הגרסה שלה. האובייקט נושא מצביע לטבלה של המחלקה שלו, והקריאה a.ring() הופכת ל"קרא את הכתובת מהטבלה של a וקפוץ אליה".

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

  • לא בהכרח בלי גוף. מתודה וירטואלית יכולה להכיל מימוש ברירת מחדל. מתודה בלי גוף שהיורשות חייבות לממש נקראת abstract, וב-C++ "pure virtual", עם = 0.
  • לא העמסה. כמה גרסאות באותו שם באותה מחלקה הן העמסה, והיא נפתרת בקומפילציה.
  • לא static. מתודה סטטית שייכת למחלקה ואינה נבחרת לפי אובייקט.

דריסה אחת לא נועלת את השרשרת: גם נכד יכול לדרוס שוב את הגרסה של הבן. מי שרוצה לעצור את השרשרת צריך לסגור אותה במפורש: ב-Java עם המילה final על הדריסה, וב-C# עם sealed override.

Java
class Alarm {
    String ring() { return "beep"; }               // virtual already, no keyword needed
}
class LoudAlarm extends Alarm {
    @Override String ring() { return super.ring().toUpperCase() + "!"; }   // super.ring(): parent version
}
class SirenAlarm extends LoudAlarm {
    @Override String ring() { return "wooo + " + super.ring(); }          // a later generation overrides again
}

public class App {
    public static void main(String[] argv) {
        Alarm[] alarms = { new Alarm(), new LoudAlarm(), new SirenAlarm() };
        for (Alarm a : alarms) System.out.println(a.ring());
    }
}
פלט
beep
BEEP!
wooo + BEEP!

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

Java
class Alarm { String ring() { return "beep"; } }
class LoudAlarm extends Alarm {
    @Override final String ring() { return "BEEP!"; }      // final closes the chain
}
class Siren extends LoudAlarm {
    @Override String ring() { return "wooo"; }
}
פלט
Siren.java:6: error: ring() in Siren cannot override ring() in LoudAlarm
    @Override String ring() { return "wooo"; }
                     ^
  overridden method is final
1 error
C#
class Job {
    public virtual void Run() { }
}

class NightJob : Job {
    public sealed override void Run() { }   // closes the chain here
}

class LateNightJob : NightJob {
    public override void Run() { }
}
פלט
Program.cs(10,26): error CS0239: 'LateNightJob.Run()': cannot override inherited member 'NightJob.Run()' because it is sealed
חזרה לתוכן העניינים

שלוש שפות, שלוש ברירות מחדל

JavaC#C++
ברירת המחדלוירטואלית, חוץ ממתודות static, private ו-finalלא וירטואליתלא וירטואלית
מה כותבים בבסיסשום דבר: אין ב-Java מילה virtualvirtual או abstractvirtual
מה כותבים ביורשתדריסה רגילה (מומלץ @Override)override חובה; new מסתיר במקום לדרוסאותה חתימה
קריאה לגרסת האבsuper.m()base.M()Base::m()

ב-C# הצירוף מחייב: אם בבסיס המתודה אינה virtual, abstract או override, אסור לכתוב override ביורשת:

C#
class Job {
    public void Run() { }
}

class NightJob : Job {
    public override void Run() { }
}
פלט
Program.cs(6,26): error CS0506: 'NightJob.Run()': cannot override inherited member 'Job.Run()' because it is not marked virtual, abstract, or override

בדוגמת ה-C++ הבאה שתי מתודות של Shape נקראות דרך אותו מצביע Shape*. ל-name() אין virtual, ולכן היעד שלה נקבע כבר בהידור, לפי הטיפוס של המצביע. ל-draw() יש virtual, והיעד שלה נקבע רק בזמן הריצה, לפי מה שנבנה בפועל.

ועוד כלל: כשמוחקים יורשת דרך מצביע לבסיס, ה-destructor של הבסיס חייב להיות וירטואלי, אחרת אין הבטחה שה-destructor של היורשת ירוץ:

C++
#include <iostream>

struct Shape {
    void name() const { std::cout << "Shape::name\n"; }            // bound by pointer type
    virtual void draw() const { std::cout << "Shape::draw\n"; }    // bound by object type
    virtual ~Shape() { std::cout << "~Shape\n"; }
};

struct Hexagon : Shape {
    void name() const { std::cout << "Hexagon::name\n"; }
    void draw() const override { std::cout << "Hexagon::draw\n"; }
    ~Hexagon() override { std::cout << "~Hexagon\n"; }
};

int main() {
    Shape* p = new Hexagon;
    p->name();
    p->draw();
    delete p;                     // virtual destructor: both destructors run
}
פלט
Shape::name
Hexagon::draw
~Hexagon
~Shape

name() אינה וירטואלית, ולכן רצה גרסת Shape, לפי סוג המצביע. draw() וירטואלית, ולכן רצה גרסת Hexagon. וה-destructor הווירטואלי דאג ששני ה-destructors ירוצו, מהיורשת אל הבסיס.

תרחיש 9: override מול new ב-C#
C#
Report r = new SalesReport();
Console.WriteLine(r.Header());
Console.WriteLine(r.Footer());
Console.WriteLine(((SalesReport)r).Footer());

class Report {
    public virtual string Header() => "generic header";
    public string Footer() => "generic footer";
}

class SalesReport : Report {
    public override string Header() => "sales header (" + base.Header() + ")";
    public new string Footer() => "sales footer";     // hides, does not override
}
פלט
sales header (generic header)
generic footer
sales footer

Header מסומנת virtual בבסיס ו-override ביורשת. הקריאה דרך משתנה מטיפוס Report מגיעה לגרסה של SalesReport, וזו קוראת ל-base.Header() כדי לשלב בתוכה את גרסת האב.

Footer אינה וירטואלית, ו-SalesReport רק מסתירה אותה עם new. לכן דרך Report רצה גרסת הבסיס, generic footer.

אחרי המרה ל-SalesReport הטיפוס המוצהר משתנה, ורק אז מתקבל sales footer.

ב-Java אותו קוד היה מתנהג אחרת: שם Footer הייתה וירטואלית בלי שום מילת מפתח, ושתי הקריאות היו מחזירות sales footer.

טעויות נפוצות
  • למתודה וירטואלית אין גוף בבסיס, וכל יורשת מחויבת לכתוב לה מימוש. זה תיאור של abstract. וירטואלית רשאית להידרס, לא חייבת, ויכול להיות לה גוף.
  • הגרסה של פונקציה וירטואלית נקבעת בקומפילציה לפי הטיפוס המוצהר. היא נפתרת בזמן ריצה, לפי האובייקט.
  • פונקציה וירטואלית מסתירה את מתודת הבסיס. הסתרה היא new ב-C#. מתודה וירטואלית נדרסת, והקריאה דרך הבסיס מגיעה ליורשת.
  • וירטואליות נועלת את ההתנהגות ומונעת מהיורשות לשנות אותה. היא בדיוק מה שמאפשר ליורשות לשנות.
  • ב-Java צריך לכתוב virtual כדי שהדריסה תעבוד. אין ב-Java מילה כזו. מתודות מופע וירטואליות מעצמן.
בדקו את עצמכם
ב-C# הבסיס מגדיר public void Save() בלי virtual, והיורשת כותבת public override void Save(). מה יקרה?

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

ב-C++ Base* p = new Derived;, והמתודה render() קיימת בשתי המחלקות אבל אינה virtual. איזו גרסה תרוץ ב-p->render()?

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

ב-Java B דורסת את m() של A, ו-C extends B רוצה לדרוס שוב. מתי זה ייכשל?

רק אם B סימנה את הגרסה שלה final. אחרת כל דור רשאי לדרוס מחדש.

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

IComparable: סדר טבעי למחלקה

מה CompareTo מחזיר, ואיזה חוזה עליו לקיים

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

לממשק יש שתי צורות. הגנרית, IComparable<T> עם int CompareTo(T other), היא הצורה המומלצת: המהדר מוודא שמשווים לאותו טיפוס, וטיפוס ערך לא עובר boxing. הצורה הישנה, IComparable בלי פרמטר טיפוס, מגדירה int CompareTo(object obj).

המתודה מחזירה int, לא bool. מה שנקרא ממנו הוא הסימן בלבד:

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

החזרה של 300 או של -7 שקולה לחלוטין להחזרה של 1 או -1. הגודל של המספר לא מודד כמה מקומות מפרידים בין האובייקטים, והוא גם לא הפרש בין ערכי hashCode שלהם.

מקרה הקצה של .NET: כל מופע נחשב גדול מ-null. לכן CompareTo(null) אמור להחזיר מספר חיובי, ולא לזרוק.

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

  • עקביות: אותו זוג אובייקטים מקבל את אותה תשובה בכל פעם שמשווים אותו.
  • אנטי-סימטריה: אם a לפני b, אז בהשוואה ההפוכה b יוצא אחרי a.
  • טרנזיטיביות: אם a לפני b ו-b לפני c, אז גם a לפני c.

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

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

טעות מימוש נפוצה היא להחזיר הפרש, למשל this.x - other.x. כששני הערכים רחוקים זה מזה, החיסור של int גולש ומחליף סימן:

C#
class Program {
    static void Main() {
        int a = 2_000_000_000;
        int b = -1_500_000_000;
        Console.WriteLine(a - b);            // wraps around: looks like "a comes first"
        Console.WriteLine(a.CompareTo(b));   // correct: a is greater
    }
}
פלט
-794967296
1

לפי ההפרש, a היה נראה קטן מ-b, וזה הפוך מהאמת. a.CompareTo(b) מחזיר את הסימן הנכון בלי לחשב הפרש, ולכן משווים כך.

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

מה IComparable נותן למחלקה ב-C#, ומה הוא לא נותן

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

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

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

  • מעבר בלולאת foreach מגיע מ-IEnumerable, לא ממנו.
  • השוואת שוויון לפי ערכי השדות היא עניין של IEquatable<T> (ו-== לא משתנה בגללו).
  • שכפול באמצעות Clone() מוגדר ב-ICloneable.

ומה אם במסך אחד צריך את החדרים לפי קומה, ובמסך אחר לפי מספר? את הסדר השני לא דוחסים לתוך Room, אלא כותבים מחלקה קטנה נפרדת שמממשת IComparer<T>, כלומר מתודה int Compare(T x, T y) שמקבלת את שני הצדדים. מופע שלה מוסרים ל-Sort, כמו ByNumberDesc בתרחיש שלהלן.

תרחיש 10: חדרים לפי קומה ואחר כך לפי מספר
C#
class Room : IComparable<Room> {
    public int Floor, Number;
    public Room(int floor, int number) { Floor = floor; Number = number; }
    public int CompareTo(Room other) {
        if (other == null) return 1;                         // every instance is greater than null
        int byFloor = Floor.CompareTo(other.Floor);          // primary key
        if (byFloor != 0) return byFloor;
        return Number.CompareTo(other.Number);               // secondary key, only on a tie
    }
    public override string ToString() => Floor + "-" + Number;
}

class ByNumberDesc : IComparer<Room> {                       // an external, second order
    public int Compare(Room x, Room y) => y.Number.CompareTo(x.Number);
}

class Crate { }

class Program {
    static void Main() {
        var rooms = new List<Room> { new Room(3, 12), new Room(1, 40), new Room(3, 5) };
        rooms.Sort();                                        // no comparer: uses CompareTo
        Console.WriteLine(string.Join(" ", rooms));
        rooms.Sort(new ByNumberDesc());                      // same class, different order
        Console.WriteLine(string.Join(" ", rooms));
        Console.WriteLine(new Room(1, 1).CompareTo(null));
        Console.WriteLine("kiwi".CompareTo("apple") > 0);
        try {
            Array.Sort(new Crate[] { new Crate(), new Crate() });
        } catch (InvalidOperationException e) {
            Console.WriteLine(e.GetType().Name);
        }
    }
}
פלט
1-40 3-5 3-12
1-40 3-12 3-5
1
True
InvalidOperationException
  • rooms.Sort() בלי ארגומנט קרא ל-CompareTo של Room: קודם לפי Floor, ורק בין שני החדרים בקומה 3 הכריע Number.
  • ByNumberDesc הוא IComparer<Room> שהועבר מבחוץ, ולכן אותה רשימה סודרה לפי המספר בסדר יורד, בלי לגעת במחלקה.
  • השוואה מול null החזירה 1, כלומר חיובי.
  • "kiwi" גדולה מ-"apple" בסדר המחרוזות, ולכן התוצאה חיובית.
  • Crate לא מממשת את הממשק, ולכן Array.Sort נכשל רק בזמן הריצה.
חזרה לתוכן העניינים

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

בתרחיש הבא Player מצהירה implements Comparable<Player> ומממשת compareTo, באות c קטנה. ב-Java אין IComparable, וזה התחליף שלו: הממשק java.lang.Comparable<T> עם int compareTo(T o), ואותו כלל סימן בדיוק.

על הסדר הזה נשען Collections.sort(board) בתרחיש, וכך גם Arrays.sort והמבנים הממוינים TreeSet ו-TreeMap. את המיון לפי כינוי בונה Comparator.comparing(...), שמחזיר java.util.Comparator<T>: ממשק שהמתודה היחידה שחובה לממש בו היא int compare(T a, T b).

שני הבדלים מ-.NET שכדאי לזכור:

  • ב-Java compareTo(null) אמור לזרוק NullPointerException, ולא להחזיר ערך חיובי.
  • Arrays.sort על מערך של מחלקה שאינה Comparable מתקמפל, כי החתימה שלו מקבלת Object[]. הכישלון מגיע בזמן ריצה, כ-ClassCastException.
תרחיש 11: טבלת שיאים: סדר טבעי, Comparator ומחלקה בלי סדר
Java
import java.util.*;

class Player implements Comparable<Player> {
    final String nick; final int score;
    Player(String nick, int score) { this.nick = nick; this.score = score; }
    @Override public int compareTo(Player other) { return Integer.compare(other.score, this.score); } // higher score first
    @Override public String toString() { return nick + "=" + score; }
}

class Tile { int size; Tile(int size) { this.size = size; } }

public class Leaderboard {
    public static void main(String[] args) {
        List<Player> board = new ArrayList<>(Arrays.asList(
            new Player("mia", 70), new Player("zed", 95), new Player("bo", 81)));
        Collections.sort(board);                                   // natural order: compareTo
        System.out.println(board);
        board.sort(Comparator.comparing((Player p) -> p.nick));    // external order, class unchanged
        System.out.println(board);
        System.out.println("m".compareTo("c"));                    // only the sign matters
        try {
            "abc".compareTo(null);
        } catch (NullPointerException e) {
            System.out.println("compareTo(null): NullPointerException");
        }
        Tile[] floor = { new Tile(4), new Tile(2) };
        Arrays.sort(floor);                                        // compiles, fails at run time
    }
}
פלט
[zed=95, bo=81, mia=70]
[bo=81, mia=70, zed=95]
10
compareTo(null): NullPointerException
Exception in thread "main" java.lang.ClassCastException: Tile cannot be cast to java.lang.Comparable

השורה האחרונה בפלט היא מ-Java 8, ואחריה מודפסות שורות ה-stack trace. בגרסאות חדשות יותר ההודעה מנוסחת אחרת, אבל זו אותה חריגה.

  • compareTo של Player הופך את סדר הארגומנטים ב-Integer.compare, ולכן הסדר הטבעי כאן הוא מהניקוד הגבוה לנמוך.
  • ה-Comparator מיין את אותה רשימה לפי הכינוי, ו-Player לא השתנתה.
  • "m".compareTo("c") החזיר 10 ולא 1: המרחק בין האותיות, ומה שחשוב בו הוא רק הסימן.
  • Tile אינה Comparable, ו-Java לא תבחר בעצמה לסדר לפי השדה המספרי size. לכן המיון נכשל בזמן ריצה.
טעויות נפוצות
  • CompareTo עונה בכן או לא, ומחזיר true כשהאובייקט הנוכחי גדול. ערך ההחזרה הוא int, ומשמעותו בסימן שלו.
  • כשהאובייקט גדול חייבים להחזיר בדיוק 1. כל מספר חיובי עושה את אותה עבודה.
  • תוצאה חיובית של s1.CompareTo(s2) אומרת ש-s1 יופיע ראשון. חיובי פירושו ש-s1 יבוא אחרי s2.
  • בעזרת IComparable אפשר להגדיר כמה סדרי מיון לאותה מחלקה. הוא מגדיר סדר טבעי אחד. סדר נוסף נכתב ב-IComparer<T> או ב-Comparator<T>.
  • דריסה של Equals, העמסה של האופרטור < או מימוש IComparer בתוך המחלקה יאפשרו ל-Array.Sort(arr) למיין אותה. בלי comparer, המיון מחפש IComparable במחלקה. IComparer הוא אובייקט שמעבירים כפרמטר.
  • אם Sort החזיר סדר משובש, אפשר להריץ אותו פעם נוספת, לעבור ל-OrderBy, או להוסיף למחלקה IEquatable<T>. שני הראשונים נשענים על אותה CompareTo שבורה, ו-IEquatable<T> בכלל עוסק בשוויון ולא בסדר. רק תיקון ההשוואה יעזור.
  • ב-Java, Arrays.sort על מחלקה שאינה Comparable ייכשל כבר בהידור. הוא מתקמפל, ונכשל בזמן ריצה עם ClassCastException.
  • גם ב-Java השוואה מול null מחזירה ערך חיובי. זה הכלל של .NET. ב-Java compareTo(null) זורק NullPointerException.
בדקו את עצמכם
x.CompareTo(y) החזיר 42. מה זה אומר?

ש-x בא אחרי y בסדר הטבעי. המספר 42 עצמו לא מוסיף מידע.

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

סדר אחד, למשל הכותרת, נכתב כסדר הטבעי ב-IComparable<Book> (או Comparable<Book> ב-Java). את הסדר לפי שנה מעבירים כ-IComparer<Book> או כ-Comparator<Book> חיצוני.

מה הבעיה ב-return this.Price - other.Price; כשהמחירים מגיעים למיליארדים, ומה כותבים במקום?

החיסור עלול לגלוש ולהחזיר סימן הפוך. כותבים Price.CompareTo(other.Price) ב-C#, או Integer.compare(this.price, other.price) ב-Java.

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

By value: העברת פרמטרים לפי ערך

Java: כל פרמטר מגיע כעותק

בהעברה לפי ערך (By value) הפונקציה מקבלת העתק של מה שנשלח אליה. המשתנה שבקוד הקורא לא נמסר לה, ולכן היא לא יכולה להחליף אותו.

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

מה נשלחמה מועתקמה הקורא יראה
פרימיטיב (int, double)הערך עצמושום שינוי, גם אם הפונקציה כתבה לפרמטר
אובייקט או מערךההפניה, כלומר ה'כתובת' של האובייקטכל שינוי שנעשה בתוך האובייקט, כי שתי ההפניות מובילות אליו

מכאן נובעים כמה כללים:

  • כתיבה לשדה או לתא דרך הפרמטר, למשל w.coins -= 30 או arr[1] = 4, נראית אצל הקורא.
  • השמה של אובייקט חדש לפרמטר, כמו w = new Wallet(1000), מפנה רק את העותק למקום אחר. המשתנה של הקורא ממשיך להצביע על האובייקט המקורי.
  • לכן מתודת swap(a, b) ב-Java לא יכולה להחליף בין שני משתנים של הקורא.
  • String ו-Integer הם immutable. פעולה כמו memo = memo.toUpperCase() בתוך מתודה מייצרת אובייקט חדש, ורק העותק המקומי מצביע עליו.

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

תרחיש 12: ארנק, שער ותזכורת: שלושה פרמטרים, שלוש תוצאות
Java
public class Transfer {
    static class Wallet { int coins; Wallet(int coins) { this.coins = coins; } }

    static void pay(Wallet w, double rate, String memo) {
        rate = rate * 2;            // local copy of a primitive
        memo = memo.toUpperCase();  // a new String; only the local copy sees it
        w.coins -= 30;              // the object both references share
        w = new Wallet(1000);       // the parameter is redirected
        w.coins = 0;                // affects only the new, private object
    }

    static void swap(Wallet a, Wallet b) { Wallet t = a; a = b; b = t; }

    public static void main(String[] args) {
        Wallet mine = new Wallet(100);
        double rate = 1.5;
        String memo = "rent";
        pay(mine, rate, memo);
        System.out.println(mine.coins + " " + rate + " " + memo);

        Wallet left = new Wallet(1), right = new Wallet(2);
        swap(left, right);
        System.out.println(left.coins + " " + right.coins);
    }
}
פלט
70 1.5 rent
1 2
  • rate הוא double: הכפל נעשה בעותק, ו-rate של main נשאר 1.5.
  • w.coins -= 30 פעל על אובייקט הארנק ששתי ההפניות חולקות, ולכן mine.coins ירד ל-70.
  • אחרי w = new Wallet(1000) הפרמטר כבר לא קשור לארנק של main, ולכן האיפוס w.coins = 0 לא נגע בו.
  • toUpperCase יצרה מחרוזת חדשה שרק העותק memo ראה, ובחוץ נשאר rent.
  • swap החליפה בין שני עותקים של הפניות, ו-left ו-right של main לא זזו.
חזרה לתוכן העניינים

C#: struct, class, ובהעברה לפי הפניה ref, out ו-in

בתרחיש שלהלן Coord מוגדר כ-struct ו-Marker כ-class, ושניהם נשלחים לאותה Shift. אחרי הקריאה השדה של הראשון לא זז, והשדה של השני השתנה. ההסבר: גם ב-C#, כשאין מילת מפתח מיוחדת, כל ארגומנט עובר לפי ערך, ומה שנחשב 'הערך' תלוי בסוג הטיפוס:

  • ב-struct, כמו ב-int ובכל טיפוס ערך, הערך הוא כל השדות יחד. המתודה קיבלה העתק שלם שלהם, וכתבה רק לתוכו.
  • ב-class, כמו במערך, המשתנה מחזיק הפניה. היא שהועתקה, בדיוק כמו ב-Java, ולכן הכתיבה הגיעה לאובייקט המשותף.

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

מילת מפתחאתחול לפני הקריאהמה המתודה רשאית או חייבת
refחובהלקרוא את המשתנה ולהחליף אותו, כולל להפנות אותו לאובייקט חדש
outלא נדרשחייבת להציב בו ערך לפני שהיא חוזרת
in (C# 7.2)חובהרק לקרוא: הפניה לקריאה בלבד
תרחיש 13: struct מול class, ואחר כך ref, out ו-in
C#
struct Coord { public int Row; }
class Marker { public int Row; }

class Program {
    static void Shift(Coord c, Marker m) { c.Row = 50; m.Row = 50; }
    static void Swap(ref Marker x, ref Marker y) { Marker t = x; x = y; y = t; }
    static bool TryHalf(int n, out int half) {
        half = n / 2;                        // an out parameter must be assigned before returning
        return n % 2 == 0;
    }
    static int Peek(in Coord c) => c.Row;   // read-only reference

    static void Main() {
        Coord c = new Coord { Row = 8 };
        Marker m = new Marker { Row = 8 };
        Shift(c, m);
        Console.WriteLine(c.Row + " " + m.Row);

        Marker first = new Marker { Row = 1 }, second = new Marker { Row = 2 };
        Swap(ref first, ref second);         // ref in the definition and in the call
        Console.WriteLine(first.Row + " " + second.Row);

        bool even = TryHalf(14, out int h);  // h needs no value before the call
        Console.WriteLine(even + " " + h);
        Console.WriteLine(Peek(in c));
    }
}
פלט
8 50
2 1
True 7
8
  • Coord הוא struct, ולכן Shift שינתה העתק שלם ו-c.Row נשאר 8.
  • Marker היא class, ולכן Shift כתבה לאותו אובייקט ו-m.Row הפך ל-50.
  • עם ref, ההחלפה ב-Swap נעשתה במשתנים של Main עצמם, משהו שב-Java אי אפשר לכתוב.
  • h הוצהר בלי ערך, ו-TryHalf הציבה בו 7 דרך out.
  • Peek קיבלה את c דרך in: הפניה בלי העתקה, אבל בלי רשות לכתוב.

המהדר אוכף את שני כללי האתחול. משתנה לא מאותחל שנשלח ב-ref, ומתודה ששוכחת להציב ערך בפרמטר out, נכשלים שניהם בהידור:

C#
class Program {
    static void Bump(ref int n) { n++; }
    static void Fill(out int n) { }          // forgets to assign n

    static void Main() {
        int total;                           // declared, never assigned
        Bump(ref total);
    }
}
פלט
Program.cs(3,17): error CS0177: The out parameter 'n' must be assigned to before control leaves the current method
Program.cs(7,18): error CS0165: Use of unassigned local variable 'total'
טעויות נפוצות
  • Java מעבירה פרימיטיבים לפי ערך ואובייקטים לפי הפניה. גם באובייקט מועבר ערך: ההעתק של ההפניה. לכן השמה לפרמטר לא משפיעה בחוץ.
  • אם המתודה מציבה ערך חדש בפרמטר, גם המשתנה של הקורא מתעדכן. זה קורה רק עם ref או out ב-C#. בהעברה רגילה, בשתי השפות, ההשמה נשארת מקומית.
  • שינוי שדה של אובייקט דרך הפרמטר נשאר בתוך המתודה. הוא נראה בחוץ, כי ההעתק והמקור מפנים לאותו אובייקט.
  • פרמטר שהועבר לפי ערך הופך לקבוע, כמו final. מותר לכתוב אליו. הכתיבה פשוט לא יוצאת מהמתודה.
  • כשהמתודה מסתיימת, הערך האחרון של הפרמטר נכתב חזרה למשתנה ששלחתם. שום דבר לא חוזר. ב-Transfer, ה-rate של main נשאר 1.5 גם אחרי ש-pay הכפילה את העותק.
  • פרמטר שומר את הערך שלו עד הקריאה הבאה לאותה מתודה, ואפשר לצבור בו. כל קריאה מקבלת עותק טרי, והוא נעלם יחד עם המסגרת שלה.
  • משתנה שנשלח למתודה הופך ללא שמיש, כאילו הבעלות עליו עברה אליה. המשתנה של הקורא תקין לגמרי. ב-Transfer, main מדפיסה את mine מיד אחרי הקריאה.
  • ב-C# אין הבדל בין struct ל-class כשמעבירים אותם למתודה. struct מועתק כולו, ולכן שינוי השדות שלו לא חוזר לקורא.
בדקו את עצמכם
ב-Java, static void wipe(List<String> list) { list = new ArrayList<>(); } נקראת עם רשימה שיש בה שלושה שמות. כמה שמות יש ברשימה של הקורא אחרי הקריאה?

עדיין שלושה. ההשמה הפנתה רק את העותק של ההפניה לרשימה חדשה וריקה.

ומה אם גוף המתודה היה list.clear();?

הרשימה של הקורא תתרוקן, כי clear פועלת על האובייקט המשותף עצמו.

ב-C#, struct Temp { public int C; } נשלח ל-static void Heat(ref Temp t) { t.C += 10; }. האם הקורא יראה את התוספת?

כן. בזכות ref המתודה עובדת על המשתנה של הקורא, ולא על העתק של ה-struct.

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

Recursion: רקורסיה

שני החלקים שבלעדיהם אין רקורסיה

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

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

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

Java
import java.util.*;

public class Tree {
    static class Folder {
        final String name; final int files;
        final List<Folder> subs = new ArrayList<>();
        Folder(String name, int files) { this.name = name; this.files = files; }
        Folder add(Folder f) { subs.add(f); return this; }
    }

    static int countFiles(Folder f) {
        int total = f.files;              // handle this node
        for (Folder sub : f.subs) {       // a leaf has no subs: the recursion stops by itself
            total += countFiles(sub);     // same question on a smaller structure
        }
        return total;
    }

    public static void main(String[] args) {
        Folder root = new Folder("root", 2)
            .add(new Folder("img", 5).add(new Folder("raw", 9)))
            .add(new Folder("docs", 3));
        System.out.println(countFiles(root));
    }
}
פלט
19

countFiles סופרת את הקבצים של התיקייה שלפניה ומוסיפה את מה שמחזירה כל תת-תיקייה: 2 ב-root, 5 ו-9 בענף img, ו-3 ב-docs. תיקייה בלי תתי-תיקיות לא נכנסת ללולאה, וזה תנאי העצירה שלה.

הסיבה לבחור ברקורסיה היא בהירות. היא לא רצה מהר יותר מלולאה, ולא חוסכת זיכרון; כפי שנראה מיד, בדרך כלל היא צורכת יותר.
טעויות נפוצות
  • כל קריאה עצמית מקבלת בדיוק את הארגומנטים שקיבלה הקריאה הקודמת. כך שום דבר לא היה מתקדם. ב-countFiles כל קריאה מקבלת תיקייה אחרת, קטנה יותר.
  • פונקציה רקורסיבית חייבת להיות static ולהחזיר int. אין דרישה כזו. גם מתודת מופע יכולה לקרוא לעצמה, ו-echo שבחלק הבא מחזירה void.
  • בלי לולאה בגוף הפונקציה אין רקורסיה. החזרה נוצרת מהקריאה העצמית. הלולאה ב-countFiles רק עוברת על תתי-התיקיות, ו-echo מסתדרת בלי שום לולאה.
  • רקורסיה מריצה קטע קוד שוב ושוב כמספר שנקבע מראש, או מפזרת אותו על כמה ליבות. מספר הקריאות נקבע מהקלט ומתנאי העצירה, וכולן רצות באותו thread, אחת בתוך השנייה.
חזרה לתוכן העניינים

מעקב: מה מודפס בדרך למטה ומה בדרך למעלה

בפלט של echo(3) שלהלן כל אחד מהמספרים 1, 2 ו-3 מופיע פעמיים, פעם עם in ופעם עם out. זה עובד כי לכל הפעלה יש n משלה, במסגרת משלה: הקריאה הפנימית מקבלת ערך אחר, ולא נוגעת בערך של מי שהפעיל אותה.

שתי ההדפסות נבדלות רק בצד של הקריאה העצמית שבו הן כתובות. in כתובה לפניה, ולכן יוצאת כבר בדרך למטה, מ-3 עד 1. out כתובה אחריה, ולכן מחכה לחזרה ויוצאת הפוך, מ-1 עד 3.

תרחיש 14: הדפסה משני צידי הקריאה
Java
public class Echo3 {
    static void echo(int n) {
        if (n == 0) return;                 // base case: returns silently for 0
        System.out.print("in" + n + " ");   // on the way down
        echo(n - 1);
        System.out.print("out" + n + " ");  // on the way back up
    }
    public static void main(String[] args) {
        echo(3);
        System.out.println();
    }
}
פלט
in3 in2 in1 out1 out2 out3
  1. echo(3) מדפיסה in3 וקוראת ל-echo(2), שמדפיסה in2 וקוראת ל-echo(1), שמדפיסה in1.
  2. echo(0) פוגעת בתנאי העצירה וחוזרת מיד, בלי להדפיס.
  3. השליטה חוזרת ל-echo(1), שממשיכה מהשורה שאחרי הקריאה ומדפיסה out1. אחריה echo(2) מדפיסה out2, ובסוף echo(3) מדפיסה out3.
  4. כל קריאה הדפיסה את ה-n שלה בשני המקומות, כי ה-n שלה לא השתנה בזמן שהקריאות הפנימיות רצו.
חזרה לתוכן העניינים

מסגרות על המחסנית, ומה קורה כשהיא מתמלאת

על כל קריאה ה-thread מוסיף למחסנית הקריאות שלו מסגרת חדשה (stack frame). במסגרת נשמרים הפרמטרים והמשתנים המקומיים של אותה קריאה, והיא משתחררת רק כשהקריאה חוזרת.

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

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

  • ב-Java נזרקת StackOverflowError. היא Error ולא Exception, ולכן unchecked: המהדר לא דורש לתפוס אותה או להכריז עליה ב-throws (הכרזה כזו מותרת, פשוט מיותרת).
  • ב-.NET נזרקת StackOverflowException. אי אפשר לתפוס אותה, והתהליך כולו מסתיים.

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

תרחיש 15: ספירת מסגרות, ותנאי עצירה שלא מושג
Java
public class Frames {
    public static void main(String[] args) {
        System.out.println(digits(40917) + " digits, calls=" + calls);
        try {
            countdown(7);                   // 7, 5, 3, 1, -1, -3 ... never 0
        } catch (StackOverflowError e) {
            Throwable t = e;
            System.out.println("StackOverflowError after more than 1000 frames: " + (depth > 1000));
            System.out.println("is an Exception: " + (t instanceof Exception));
        }
    }

    static int calls = 0;
    static int digits(int n) {
        calls++;
        if (n < 10) return 1;               // base case
        return 1 + digits(n / 10);          // the addition waits for the inner call
    }

    static int depth = 0;
    static int countdown(int n) {
        depth++;
        if (n == 0) return 0;               // a base case that odd numbers never hit
        return countdown(n - 2);
    }
}
פלט
5 digits, calls=5
StackOverflowError after more than 1000 frames: true
is an Exception: false
  • digits(40917) קראה ל-digits(4091), (409), (40) ו-(4): חמש קריאות, וברגע השיא חמש מסגרות פתוחות זו מעל זו.
  • ה-1 של כל רמה מתווסף רק בדרך חזרה: 1, 2, 3, 4 ולבסוף 5.
  • ל-countdown יש תנאי עצירה, אבל צעד של 2 מ-7 מדלג על האפס. המסגרות נערמו עד שהמחסנית נגמרה.
  • השורה האחרונה מאשרת ש-StackOverflowError לא נמצאת מתחת ל-Exception בהיררכיה.
חזרה לתוכן העניינים

רקורסיית זנב, ומתי לולאה עדיפה

ברקורסיית זנב (Tail Recursion) הקריאה העצמית היא הצעד האחרון בפונקציה: אחרי שהיא חוזרת אין שום חישוב נוסף.

n * product(n - 1) איננה רקורסיית זנב, כי הכפל מחכה לתוצאה של הקריאה. productAcc(n - 1, acc * n) כן, כי התוצאה החלקית נצברת בפרמטר ואין מה לעשות אחרי שהקריאה חוזרת.

האם productAcc שבקוד הבא חוסכת מסגרות? לא. javac וה-JVM לא מבצעים tail-call elimination, כך שכל קריאת זנב פותחת מסגרת כמו כל קריאה אחרת; ההמרה ללולאה אפשרית, אבל רק אם אתם כותבים אותה בעצמכם, כמו productLoop.

Java
public class Tail {
    // not a tail call: the multiplication runs after the inner call returns
    static long product(int n) { return n == 1 ? 1 : n * product(n - 1); }

    // tail call: nothing is left to do after the inner call
    static long productAcc(int n, long acc) { return n == 1 ? acc : productAcc(n - 1, acc * n); }

    // the same tail call, written as a loop
    static long productLoop(int n) {
        long acc = 1;
        while (n > 1) { acc *= n; n--; }
        return acc;
    }

    static long sumAcc(long n, long acc) { return n == 0 ? acc : sumAcc(n - 1, acc + n); }

    public static void main(String[] args) {
        System.out.println(product(6) + " " + productAcc(6, 1) + " " + productLoop(6));
        try {
            System.out.println(sumAcc(1_000_000, 0));
        } catch (StackOverflowError e) {
            System.out.println("tail call, still StackOverflowError");
        }
    }
}
פלט
720 720 720
tail call, still StackOverflowError

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

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

ובשפות אחרות? ב-C# האופטימיזציה הזו לא מובטחת. ב-CPython היא לא קיימת בכלל, ו-total שלהלן נעצרת במגבלת העומק, 1000 כברירת מחדל, אף שהקריאה שלה בזנב:

Python
import sys

def total(n, acc=0):
    # a tail call, but CPython never removes it
    return acc if n == 0 else total(n - 1, acc + n)

print(sys.getrecursionlimit())
print(total(500))
try:
    total(5000)
except RecursionError as e:
    print(type(e).__name__ + ": " + str(e))
פלט
1000
125250
RecursionError: maximum recursion depth exceeded

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

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

טעויות נפוצות
  • ב-Java רקורסיית זנב לא מוסיפה מסגרות, ולכן היא בטוחה בכל עומק. Java לא מבצעת את האופטימיזציה הזו. כל קריאה עדיין פותחת מסגרת.
  • בגלישת מחסנית ב-Java אפשר לתפוס StackOverflowException, להמשיך את הרקורסיה, וחובה להכריז עליה כי היא checked. ב-Java זו StackOverflowError, unchecked. ב-.NET ה-StackOverflowException לא ניתנת לתפיסה ומסיימת את התהליך.
  • ה-GC ינקה מסגרות ישנות, או שה-JVM תגדיל את המחסנית כשצריך. אף אחד מהם לא קורה. גודל המחסנית קבוע, והמסגרות משתחררות רק כשהקריאות חוזרות.
  • ה-JIT יזהה רקורסיה עמוקה ויהפוך אותה ללולאה. ה-JIT מהדר את המתודה לקוד מכונה, אבל כל קריאה עדיין פותחת מסגרת משלה.
  • כל הקריאות הרקורסיביות משתמשות באותו עותק של המשתנים המקומיים. לכל קריאה מסגרת משלה, עם עותק משלה.
  • לולאה עדיפה כי משתנה מקומי שצובר תוצאה מתאפס בכל קריאה רקורסיבית. לצבירה יש פתרון פשוט, פרמטר מצטבר. הסיבה האמיתית להעדיף לולאה היא עומק המחסנית.
  • ב-Python מגבלת העומק עולה כשמדובר ברקורסיית זנב. המגבלה זהה לכל רקורסיה, ו-CPython לא ממיר קריאות זנב ללולאה.
  • רקורסיה צורכת יותר זיכרון כי קוד הפונקציה מועתק בכל קריאה. הקוד קיים פעם אחת. מה שמצטבר הוא מסגרות במחסנית.
בדקו את עצמכם
מה ידפיס show(3) עבור static void show(int k) { if (k <= 0) return; System.out.print(k); show(k - 1); System.out.print(k); }?

321123. ההדפסה הראשונה מתבצעת בירידה (3, 2, 1), show(0) חוזרת בלי להדפיס, וההדפסה השנייה מתבצעת בחזרה (1, 2, 3).

ומה ידפיס twice(3) עבור static void twice(int k) { if (k <= 0) return; System.out.print(k); twice(k - 1); twice(k - 1); }?

3211211. twice(1) מדפיסה 1. twice(2) מדפיסה 2 ואחריו פעמיים את הפלט של twice(1), כלומר 211. twice(3) מדפיסה 3 ואחריו פעמיים 211.

פונקציה רקורסיבית ב-Java מחשבת אורך של שרשרת צמתים מקושרת. למה היא מסוכנת כשבשרשרת חמישה מיליון צמתים?

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

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

Exception: חריגות

זריקה, תפיסה ומה המנגנון נותן

חריגה (Exception) היא אובייקט שמתאר שגיאה או מצב לא צפוי שהתגלה בזמן ריצה.

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

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

Java
public class Order {
    public static void main(String[] args) {
        int share = 0;
        try {
            share = 12 / args.length;
        } catch (Exception e) {              // the general type first
            System.out.println("general");
        } catch (ArithmeticException e) {    // can never be reached
            System.out.println("division");
        }
    }
}
פלט
Order.java:8: error: exception ArithmeticException has already been caught
        } catch (ArithmeticException e) {    // can never be reached
          ^
1 error

חריגה שאף catch לא תפס מסיימת את ה-thread שבו היא נזרקה, ומודפס stack trace.

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

Java
public class Codes {
    // error-code style: every caller has to remember to test the result
    static int ageOrMinusOne(String s) { return s.matches("[0-9]+") ? Integer.parseInt(s) : -1; }

    // exception style: the normal path carries no checks
    static int age(String s) { return Integer.parseInt(s); }

    public static void main(String[] args) {
        int first = ageOrMinusOne("4x");
        if (first == -1) System.out.println("code path: bad age");
        try {
            int sum = age("31") + age("4x") + age("12");
            System.out.println(sum);
        } catch (NumberFormatException e) {
            System.out.println("exception path: " + e.getMessage());
        }
    }
}
פלט
code path: bad age
exception path: For input string: "4x"

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

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

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

checked ו-unchecked ב-Java

בראש ההיררכיה עומדת Throwable, ומתחתיה שני ענפים. Error מייצגת תקלות חמורות של סביבת הריצה, למשל OutOfMemoryError או StackOverflowError. הענף השני הוא Exception, ובתוכו יושבת RuntimeException.

סוגמי שייך אליומה המהדר דורש
uncheckedRuntimeException וכל צאצאיה: NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException, ClassCastException, IllegalArgumentException, IllegalStateException; וגם Error וכל צאצאיהשום דבר
checkedכל השאר: Exception עצמה, IOException ו-FileNotFoundException שיורשת ממנה, SQLException, InterruptedException, ClassNotFoundExceptionלתפוס ב-catch או להכריז ב-throws

מה ההבחנה הזו לא אומרת? רק המהדר מבדיל בין הסוגים; בזמן ריצה שניהם אובייקטים רגילים, וגם ה-JVM וגם throw בקוד שלכם מייצרים את שניהם. ו-unchecked איננה מסוכנת יותר: catch תופס אותה בדיוק באותה דרך.

בתרחיש שבהמשך תראו ש-throws על מתודה מעביר את החובה הלאה ולא מוחק אותה: כל מי שקורא לה צריך בתורו catch או throws משלו. ל-C# אין את המנגנון הזה בכלל, לא חריגות checked ולא throws.

פרט שאוהבים לבדוק: חלוקת מספר שלם באפס זורקת ArithmeticException, ואילו חלוקה של double באפס מחזירה Infinity בשקט.

Java
public class Div {
    public static void main(String[] args) {
        System.out.println(9.0 / 0);         // floating point: no exception
        int zero = 0;
        System.out.println(9 / zero);        // integer division by zero
    }
}
פלט
Infinity
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Div.main(Div.java:5)
תרחיש 16: הכרזה בלי טיפול
Java
public class Nap {
    static void pause() throws InterruptedException {
        Thread.sleep(5);
    }
    public static void main(String[] args) {
        pause();
        System.out.println("awake");
    }
}

javac עוצר בשורה 6, על הקריאה pause();, עם השגיאה unreported exception InterruptedException, ומוסיף שהחריגה הזו צריכה להיתפס או להיות מוכרזת. ההידור נכשל, ולא נוצר קובץ class.

  • InterruptedException יורשת ישירות מ-Exception ולא מ-RuntimeException, ולכן היא checked.
  • pause מכריזה עליה כמו שצריך, אבל main קוראת לה בלי catch ובלי throws משלה.
  • התוצאה היא שגיאת הידור: אף שורה לא רצה, ו-awake לא מודפס.
  • שני תיקונים אפשריים: להוסיף ל-main את throws InterruptedException, או לעטוף את הקריאה ב-try { pause(); } catch (InterruptedException e) { ... }.
חזרה לתוכן העניינים

finally ו-multi-catch

Fin שלהלן בודק את finally בשלושה מצבים: יציאה ב-return מתוך try בלי חריגה, חריגה שנתפסה ו-catch שיצא ב-return, וקריאה ל-System.exit. בשני הראשונים הוא רץ; בשלישי לא, כי התהליך עצמו נגמר, וזה המקרה היחיד שבו finally מדולג.

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

מקרה עדין: בתוך try כתוב return של משתנה פרימיטיבי, וה-finally כותב למשתנה ערך אחר. מי שקרא יקבל את הערך הקודם, כי ערך ההחזרה חושב ונשמר עוד לפני ש-finally התחיל.

ב-parse רואים גם multi-catch, תוספת של Java 7: הסוגריים של catch אחד מונים שני סוגים, וקו אנכי מפריד ביניהם. מי שכותב שם פסיק או && מקבל שגיאת תחביר.

תרחיש 17: return לפני finally, בלוק אחד לשתי חריגות, ו-System.exit
Java
public class Fin {
    static int attempts() {
        int tries = 3;
        try {
            return tries;                    // the value 3 is stored for the return here
        } finally {
            tries = 100;                     // too late: changes only the local variable
            System.out.println("cleanup");
        }
    }

    static int parse(String text) {
        try {
            return 60 / Integer.parseInt(text);
        } catch (NumberFormatException | ArithmeticException e) {   // one block, two types
            System.out.println("bad input: " + e.getClass().getSimpleName());
            return -1;
        } finally {
            System.out.println("finally for " + text);
        }
    }

    public static void main(String[] args) {
        System.out.println(attempts());
        System.out.println(parse("x7"));
        System.out.println(parse("0"));
        try {
            System.out.println("exiting");
            System.exit(0);
        } finally {
            System.out.println("this line never prints");
        }
    }
}
פלט
cleanup
3
bad input: NumberFormatException
finally for x7
-1
bad input: ArithmeticException
finally for 0
-1
exiting
  • ב-attempts, return tries שמר את 3. finally רץ אחר כך, הדפיס cleanup וכתב 100 למשתנה, אבל הערך השמור כבר היה 3.
  • ב-parse, "x7" נכשל בהמרה ו-0 נכשל בחלוקה. אותו בלוק catch טיפל בשניהם.
  • finally של parse רץ בשתי הפעמים, אחרי ה-catch ולפני שה--1 חזר למי שקרא.
  • אחרי System.exit(0) התהליך הסתיים, וה-finally האחרון לא הודפס.
חזרה לתוכן העניינים

try-with-resources: סגירה אוטומטית

למחלקה Handle בתרחיש יש close(), והיא מממשת AutoCloseable; זה כל מה שצריך כדי להצהיר עליה בסוגריים שאחרי try, בתחביר שנוסף ב-Java 7. מרגע זה הקריאה ל-close היא באחריות השפה: היא תתבצע ביציאה מהבלוק בכל מקרה, אם הגוף הצליח ואם נזרקה בו חריגה.

  • החריגה לא נבלעת בדרך: אחרי הסגירה היא מגיעה ל-catch שמתאים לה.
  • הסגירה מקדימה את ה-catch וה-finally של אותו try, ולא באה אחריהם.
  • מי שנפתח אחרון נסגר ראשון.
  • ב-C# הרעיון נקרא using, והמשאב צריך לממש IDisposable.
תרחיש 18: שלושה משאבים וחריגה באמצע
Java
public class Res {
    static class Handle implements AutoCloseable {
        private final String label;
        Handle(String label) { this.label = label; System.out.println("acquire " + label); }
        @Override public void close() { System.out.println("release " + label); }
    }

    public static void main(String[] args) {
        try (Handle cfg = new Handle("config");
             Handle sock = new Handle("socket");
             Handle log = new Handle("log")) {
            System.out.println("sending");
            throw new IllegalArgumentException("port 0");
        } catch (IllegalArgumentException e) {
            System.out.println("handled: " + e.getMessage());
        } finally {
            System.out.println("done");
        }
    }
}
פלט
acquire config
acquire socket
acquire log
sending
release log
release socket
release config
handled: port 0
done
  • הפתיחה הולכת לפי סדר ההצהרה: config, socket, log.
  • הגוף זורק אחרי sending. עוד לפני שמישהו מטפל בחריגה, שלושת המשאבים משתחררים מהאחרון לראשון.
  • רק אחר כך ה-catch מקבל את החריגה עם ההודעה שלה, ובסוף רץ finally.
חזרה לתוכן העניינים

איפה תופסים, ומה זה עולה בביצועים

את הכלל הראשון כבר ראיתם ב-Codes: שלוש קריאות שעלולות להיכשל חולקות catch אחד, ולכן הקוד שמבצע את העבודה נקרא ברצף.

שלושה הרגלים להימנע מהם:

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

catch (Exception e) שולף כל תקלה, גם כזו שאיש לא תכנן. פונקציית עזר עמוקה לא יודעת מה לעשות עם בעיה כזו, ולכן אצלה תפיסה כללית בעיקר מעלימה אותה; בשכבה העליונה, למשל בלולאה שמקבלת בקשות בשרת, יש מספיק הקשר כדי לרשום ביומן, להודיע ולהמשיך.

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

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

תרחיש 19: סריקת עץ שנעצרת בפריט פגום
Java
import java.util.*;

public class Scan {
    static class Node {
        final String name; final boolean broken; final List<Node> kids = new ArrayList<>();
        Node(String name, boolean broken) { this.name = name; this.broken = broken; }
        Node with(Node k) { kids.add(k); return this; }
    }

    static int visited = 0;

    static void walk(Node n) {                      // no try-catch at any depth
        visited++;
        if (n.broken) throw new IllegalStateException("corrupt entry: " + n.name);
        for (Node k : n.kids) walk(k);
    }

    public static void main(String[] args) {
        Node top = new Node("top", false)
            .with(new Node("a", false).with(new Node("a1", false).with(new Node("a1x", true))))
            .with(new Node("b", false));
        try {
            walk(top);                              // the one place that catches
            System.out.println("scan complete");
        } catch (IllegalStateException e) {
            System.out.println("scan stopped after " + visited + " entries: " + e.getMessage());
        }
    }
}
פלט
scan stopped after 4 entries: corrupt entry: a1x
  • ב-walk אין try בכלל. החריגה נזרקה בעומק הרביעי, ב-a1x.
  • היא עברה דרך כל המסגרות הפתוחות עד ל-main, ולכן הענף b לא נסרק ו-scan complete לא הודפס.
  • ל-throw לא משנה שכל המסגרות בדרך שייכות לאותה מתודה: הוא חוצה אותן כמו כל שרשרת קריאות. finally, אילו היה כתוב ב-walk, היה רק מריץ ניקוי בדרך, בלי לשנות לאן החריגה מגיעה.
  • המשתמש קיבל הודעה אחת. אילו כל רמה הייתה תופסת ומחזירה ערך ברירת מחדל, הסריקה הייתה ממשיכה והתקלה הייתה נעלמת.

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

Java
public class Tokens {
    // control flow through exceptions: every bad token pays for a full throw
    static boolean isNumberSlow(String s) {
        try { Integer.parseInt(s); return true; }
        catch (NumberFormatException e) { return false; }
    }

    // the same answer (for unsigned digits) with a plain check: no exception object at all
    static boolean isNumberFast(String s) {
        if (s.isEmpty()) return false;
        for (char c : s.toCharArray()) if (c < '0' || c > '9') return false;
        return true;
    }

    public static void main(String[] args) {
        String[] tokens = {"12", "x", "7", "--", "300"};
        int slow = 0, fast = 0;
        for (String t : tokens) {
            if (isNumberSlow(t)) slow++;
            if (isNumberFast(t)) fast++;
        }
        System.out.println(slow + " " + fast);
    }
}
פלט
3 3

על "12", "7" ו-"300" הגרסה האיטית כמעט לא שילמה דבר, כי הכניסה ל-try עצמה כמעט חינמית. אבל "x" ו-"--" הפעילו throw של ממש: נבנה אובייקט NumberFormatException, וזמן הריצה חיפש catch מתאים במעלה המחסנית. המחיר גדל עם מספר הזריקות, ולכן קובץ עם מיליוני אסימונים פגומים ירגיש אותו, ואילו isNumberFast לא יוצרת שום אובייקט.

ומה בדיוק נבנה? גם בלי לזרוק:

Java
public class Cost {
    static Exception make() { return new IllegalStateException("quota"); }
    public static void main(String[] args) {
        Exception e = make();                // created, not thrown
        System.out.println("nothing was printed by the creation");
        System.out.println(e.getStackTrace()[0].getMethodName());  // the trace was captured at creation
    }
}
פלט
nothing was printed by the creation
make

Cost מראה מה נכלל בבנייה של חריגה. כבר ב-make נשמרה תמונת המחסנית, ובה שם המתודה שבה האובייקט נוצר, אף שהוא מעולם לא נזרק. ובכל זאת שום דבר לא הודפס: stack trace מגיע למסך רק כשחריגה לא נתפסה, או כשקוראים ל-printStackTrace.

טעויות נפוצות
  • חריגות checked קיימות רק בזמן הידור, ואין להן אובייקט בזמן ריצה. גם checked וגם unchecked הן אובייקטים רגילים בזמן ריצה.
  • רק ה-JVM זורקת חריגות unchecked. גם הקוד שלכם זורק אותן, למשל throw new IllegalArgumentException(...).
  • IOException יורשת מ-RuntimeException, ולכן לא חייבים לטפל בה. היא checked, והמהדר דורש catch או throws.
  • אם המתודה הנקראת מכריזה throws IOException, הקורא פטור. הקורא חייב לתפוס או להכריז בעצמו, אחרת יש שגיאת הידור.
  • try-with-resources סוגר רק כשיש חריגה, או רק אחרי ש-catch ו-finally סיימו. הוא סוגר תמיד, וזה קורה לפני catch ו-finally.
  • כל כניסה ל-try מקצה מבנה בערמה, ולכן try הוא מה שמאט. הכניסה כמעט חינמית. המחיר הוא בזריקה.
  • בסריקה רקורסיבית שצריכה להיעצר, תופסים בכל רמה ומחזירים ערך ברירת מחדל. כך הסריקה ממשיכה והשגיאה מוסתרת. נותנים לחריגה לעלות ותופסים פעם אחת למעלה.
  • מנגנון החריגות מאתר כבר בהידור טעויות בלוגיקה, ואפילו שגיאות תחביר. הוא פועל רק בזמן ריצה. קוד עם שגיאת תחביר בכלל לא מגיע לריצה, ולוגיקה שגויה שלא זורקת עוברת בשקט.
  • כשיש try-catch, כבר לא צריך לבדוק קלט. חריגה מאפשרת להגיב לקלט פגום; היא לא קובעת בשבילכם מהו קלט תקין.
  • תפיסת חריגות מבטיחה שהתהליך לעולם לא יקרוס. יש מצבים, למשל זיכרון שאזל עד הסוף, שאין מהם ממש התאוששות.
  • catch מריץ שוב את הקוד שנכשל, או מטפל בתקלה ב-thread נפרד. הוא רץ פעם אחת, באותו thread, ועושה רק את מה שכתבתם בו.
  • חריגה unchecked תמיד מפילה את התוכנית ואי אפשר לתפוס אותה. אפשר לתפוס אותה בדיוק כמו checked. ההבדל הוא רק בדרישת המהדר.
בדקו את עצמכם
ClassNotFoundException: checked או unchecked?

checked. היא נמצאת בענף של Exception ולא תחת RuntimeException.

מישהו כתב catch (IOException, SQLException e). מה לא בסדר, ומה התיקון?

פסיק אינו תחביר חוקי. ב-multi-catch מפרידים בקו אנכי: catch (IOException | SQLException e).

מה ידפיסו System.out.println(5.0 / 0) ו-System.out.println(5 / 0)?

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

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

Bytecode, JVM ו-main

Bytecode: שפת הביניים של Java

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

javac מתרגם כל מחלקה שבקובץ .java לקובץ .class משלה, ובו JVM bytecode. הכלי javap -c מציג את הפקודות:

Java
public class Fees {
    static int total(int price, int qty) {
        return price * qty + 5;
    }
}
class Receipt { }
Bash
javac Fees.java      # one source file, two classes
ls *.class
javap -c Fees
פלט
Fees.class
Receipt.class
Compiled from "Fees.java"
public class Fees {
  public Fees();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  static int total(int, int);
    Code:
       0: iload_0
       1: iload_1
       2: imul
       3: iconst_5
       4: iadd
       5: ireturn
}

מקובץ מקור אחד נוצרו שני קובצי class, אחד לכל מחלקה. השם bytecode מגיע מכך שכל פקודה (opcode) תופסת בית אחד. בפלט רואים את iload_0 ו-iload_1, הצורות הקצרות של iload, ולצידן imul, iadd ו-ireturn; invokevirtual, שקוראת למתודת מופע, היא עוד דוגמה מוכרת.

הפלט הזה גם מבהיר מה bytecode איננו. ב-Fees.class אין את הטקסט שכתבתם, ואף מעבד פיזי לא יודע להריץ iload_0 כמו שהיא. Receipt קיבלה קובץ משלה, כך שאין כאן חבילה אחת לכל התוכנית; ושום דבר לא הוצפן או שוכפל לגרסה נפרדת לכל פלטפורמה.

כל קובץ class נפתח במספר הקסם 0xCAFEBABE, ואחריו מספר הגרסה. 52 מסמן Java 8:

Python
print(open('Fees.class', 'rb').read(8).hex())   # magic, minor version, major version
פלט
cafebabe00000034

ארבעת הבתים האחרונים הם הגרסה: 0 כ-minor, ו-0x34 כ-major, שזה 52 בעשרוני.

היתרון הגדול הוא ניידות (portability): מהדרים פעם אחת, ואת ה-.class שהתקבל מעתיקים לכל מחשב שמותקנת בו סביבת Java, בכל מערכת הפעלה, בלי הידור נוסף. את זה מאפשרת ה-JVM, שכבת הפשטה שקיימת בגרסה מותאמת לכל מערכת ומעבד, ומתרגמת את ה-bytecode לקוד המכונה המקומי.

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

כדי להקשות על השחזור מעבירים את הקוד בכלי טשטוש (obfuscator), למשל ProGuard, שמחליף את השמות בשמות חסרי משמעות.

ב-.NET התפקיד המקביל שמור ל-CIL (נקרא גם MSIL או IL), וה-CLR מהדר אותו בזמן ריצה.

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

מה ה-JVM עושה, ומה לא

ה-JVM (Java Virtual Machine) היא התוכנה שמקבלת קובצי .class ומביאה אותם לריצה: טעינה, אימות והרצה של ה-bytecode, ובמקביל ניהול הזיכרון וה-threads של התוכנית. בפירוט:

  • טעינת מחלקות (Class loading), כל מחלקה כשמגיע הצורך בה.
  • אימות ה-bytecode לפני שהוא רץ.
  • הרצה, בעזרת Interpreter ומהדרי JIT.
  • ניהול זיכרון, כולל איסוף אשפה (Garbage collection) אוטומטי.
  • ניהול ה-threads של התוכנית.
שםמה הוא כולל
JVMהמכונה הווירטואלית שמריצה bytecode
JREה-JVM יחד עם ספריות המחלקות שדרושות להרצה
JDKערכת הפיתוח: javac וכלים נוספים, יחד עם סביבת ריצה

יש כאן היפוך: את Fees.class אפשר להעביר לכל מחשב, אבל את ה-JVM לא. לכל מערכת הפעלה ולכל מעבד מתקינים JVM אחרת, ובזכות זה הקובץ עצמו יכול להישאר זהה בכולם.

לפני שקוד של מחלקה רץ בפעם הראשונה, ובמיוחד כשהקובץ הגיע ממקור שאינו מוכר, עובר עליו מאמת ה-bytecode (Bytecode Verifier). הוא מוודא ש:

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

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

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

מחסנית מול ערמה

כש-report שלהלן רצה, ל-thread שהפעיל אותה יש מחסנית (JVM stack) משלו, ועליה מסגרת לכל קריאה שעוד לא חזרה, כולל זו של report. שלושת המשתנים המקומיים שלה יושבים במסגרת הזו: rate עם הערך עצמו, ו-marks ו-line עם הפניה בלבד.

מה שההפניות מצביעות עליו, המערך והאובייקט, נוצר בערמה (heap). זה אזור אחד לכל התוכנית, שכל ה-threads חולקים, ובו נמצאים כל האובייקטים וכל המערכים; מי שמנהל אותו הוא ה-Garbage collector.

Java
static void report() {
    double rate = 0.17;               // rate: a primitive in report's frame
    int[] marks = new int[4];         // marks (the reference): in the frame; the array itself: on the heap
    StringBuilder line = new StringBuilder();  // same split: reference in the frame, object on the heap
}

כש-report חוזרת, המסגרת שלה נעלמת, ואיתה rate, marks ו-line. המערך ואובייקט ה-StringBuilder נשארים בערמה, עד שה-GC יאסוף אותם כי כבר אין הפניה אליהם.

לכל אזור יש אפשרות משלו בשורת ההפעלה: -Xss לגודל המחסנית של כל thread, -Xms לגודל שבו הערמה מתחילה, ו--Xmx לתקרה שלה. ויש אזור נוסף, לנתונים על המחלקות עצמן, שנקרא Metaspace מאז Java 8.

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

טעינה, אתחול ו-ClassLoader

ה-JVM לא טוענת את כל המחלקות בהפעלה. כל מחלקה נטענת כשמגיע הצורך בה.

אתחול של מחלקה פירושו שהבלוקים ה-static שלה רצים, פעם אחת בלבד. זה קורה בשימוש הפעיל הראשון בה:

  • יצירת מופע ב-new.
  • קריאה למתודה סטטית שלה.
  • קריאה או כתיבה של שדה סטטי שלה.
  • Class.forName עם שמה.
  • אתחול של מחלקה שיורשת ממנה.
  • היותה המחלקה שמכילה את main.

חריג חשוב: קריאה של קבוע static final שערכו ידוע בזמן הידור, כמו static final int MAX_USERS = 3, לא מאתחלת את המחלקה. javac מעתיק את הערך ישירות לקוד של הקורא, כך שבזמן ריצה בכלל אין פנייה למחלקה.

תרחיש 20: מתי כל בלוק static רץ
Java
class Settings {
    static final int MAX_USERS = 3;          // compile-time constant: copied into the caller
    static int hits = 0;                     // an ordinary static field
    static { System.out.println("init Settings"); }
}

class Plugin {
    static { System.out.println("init Plugin"); }
}

public class Boot {
    static { System.out.println("init Boot"); }

    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println("main begins");
        System.out.println(Settings.MAX_USERS);
        System.out.println(Settings.hits);       // first active use of Settings
        System.out.println(Settings.hits);       // already initialized: no second block
        Class.forName("Plugin");                 // loads and initializes right away
        System.out.println("args: " + args.length);
    }
}
פלט
init Boot
main begins
3
init Settings
0
0
init Plugin
args: 0
  • Boot היא המחלקה הראשית, ולכן init Boot מודפס עוד לפני השורה הראשונה של main.
  • Settings.MAX_USERS הודפס בלי ש-Settings אותחלה: 3 הועתק לקוד של Boot בזמן הידור.
  • Settings.hits אינו final, ולכן הקריאה שלו היא שימוש פעיל: הבלוק הסטטי רץ ממש לפניה.
  • בקריאה השנייה של hits הבלוק לא רץ שוב.
  • Class.forName("Plugin") טענה ואתחלה את Plugin מיד, אף שלא נוצר ממנה אובייקט.

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

Java
class Gate {
    static { System.out.println("Gate: static block"); }
    Gate(int id) { System.out.println("Gate: constructor " + id); }
}

public class Turnstile {
    public static void main(String[] args) {
        System.out.println("before");
        new Gate(1);                 // first active use: class init, then the constructor
        new Gate(2);                 // class already initialized: constructor only
    }
}
פלט
before
Gate: static block
Gate: constructor 1
Gate: constructor 2

מי טוען בפועל? בדוגמת Loaders שבהמשך String הגיעה מטוען ה-bootstrap, שאחראי למחלקות הליבה, ומתחתיו בשרשרת יש עוד שניים: platform, ו-application שמחפש ב-classpath. הכלל ביניהם נקרא parent delegation: טוען שמתבקש מחלקה שואל קודם את ההורה, ומחפש בעצמו רק אם ההורה לא מצא.

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

Java
// plugins/Meter.java, compiled into the plugins folder (javac -d plugins plugins/Meter.java)
public class Meter {
    public static int reads = 0;
}
Java
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;

public class Loaders {
    public static void main(String[] args) throws IOException, ReflectiveOperationException {
        URL[] path = { new File("plugins").toURI().toURL() };
        // parent = null: each loader finds Meter by itself instead of delegating
        URLClassLoader first = new URLClassLoader(path, null);
        URLClassLoader second = new URLClassLoader(path, null);
        Class<?> m1 = first.loadClass("Meter");
        Class<?> m2 = second.loadClass("Meter");
        System.out.println(m1.getName().equals(m2.getName()));   // same name
        System.out.println(m1 == m2);                            // but two different classes
        m1.getField("reads").setInt(null, 5);
        System.out.println(m2.getField("reads").getInt(null));   // separate static fields
        System.out.println(String.class.getClassLoader());       // bootstrap loader shows as null
    }
}
פלט
true
false
0
null

Loaders רצה מהתיקייה שמכילה את plugins. שני הטוענים קיבלו null כהורה, כלומר הם פונים רק לטוען ה-bootstrap, שלא מכיר את Meter, ולכן כל אחד מהם מצא והגדיר אותה בעצמו.

אותו שם, אבל שתי מחלקות: הכתיבה ל-reads דרך האחת לא הגיעה לשנייה. String נטענה בטוען ה-bootstrap, ש-Java מציגה אותו כ-null.

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

כשקוד צריך מחלקה לפי שם בזמן ריצה, יש שתי דרכים. הפשוטה היא Class.forName("pkg.Foo"), שלא דוחה דבר: המחלקה נטענת באותו רגע, ובברירת המחדל גם מאותחלת, כך שה-static initializer שלה רץ (כמו Plugin בתרחיש). הגמישה היא לכתוב טוען משלכם, מחלקה שיורשת מ-ClassLoader, ואז אתם מחליטים:

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

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

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

main: נקודת הכניסה ומערך args

כשה-JVM מתחילה לרוץ, עוד אין מופע של אף מחלקה, ולכן נקודת הכניסה חייבת להיות מתודה שאפשר להפעיל בלי אובייקט. זו הסיבה למילה static בחתימה המוכרת public static void main(String[] args).

סדר האירועים בהפעלה:

  1. ה-JVM עולה.
  2. היא טוענת את המחלקה הראשית ומאתחלת אותה, כך שהבלוקים ה-static שלה רצים לפני main.
  3. היא מריצה את main ב-thread ששמו main.
  4. שאר המחלקות נטענות ומאותחלות בהמשך, כל אחת בשימוש הראשון בה.

בתרחיש שלהלן, java Greet ruth 42 ממלא את args בשני איברים בלבד, אלה שבאים אחרי שם המחלקה. לא java ולא Greet נכנסים למערך, ובזה Java שונה מ-C, שבה argv[0] הוא שם התוכנית. וכשלא נותנים אף ארגומנט, מקבלים מערך באורך 0 ולא null.

תרחיש 21: מה מגיע ל-args
Java
public class Greet {
    public static void main(String[] args) {
        System.out.println("count=" + args.length + " null? " + (args == null));
        for (int i = 0; i < args.length; i++) {
            System.out.println(i + ":" + args[i]);
        }
    }
}
פלט
> java Greet ruth 42
count=2 null? false
0:ruth
1:42
> java Greet
count=0 null? false
  • Greet הוא שם המחלקה ולא נכנס למערך. ruth הוא args[0] ו-42 הוא args[1], כמחרוזת.
  • בהרצה בלי ארגומנטים הלולאה לא רצה אף פעם, ו-args עדיין אובייקט קיים.

main בלי static מתקמפלת בלי שום שגיאה, אבל עד Java 24 ה-launcher מסרב להריץ אותה. הפלט כאן מ-Java 8; מ-Java 25 מותרת גם main של מופע, וה-launcher יוצר את האובייקט בעצמו.

Java
public class Lone {
    public void main(String[] args) {        // compiles, but no static
        System.out.println("never runs");
    }
}
פלט
Error: Main method is not static in class Lone, please define the main method as:
   public static void main(String[] args)

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

טעויות נפוצות
  • bytecode הוא קוד מכונה, ולכן הוא רץ בלי שום שכבת תרגום. זה קוד ביניים, וה-JVM היא שמריצה אותו ומתרגמת אותו לקוד מכונה.
  • אי אפשר לשחזר Java מ-bytecode, ולכן המקור מוגן. השמות נשמרים בקובץ, והשחזור קל. בשביל זה קיימים כלי טשטוש.
  • javac מייצר קוד מכונה, ולכן צריך להדר מחדש לכל מערכת הפעלה. javac מייצר bytecode אחד, ואותו קובץ רץ בכל מקום שיש בו JVM.
  • ה-JVM היא אוסף הספריות הסטנדרטיות, או ערכת כלי הפיתוח. את הספריות מוסיף ה-JRE, ואת כלי הפיתוח ה-JDK.
  • ה-JVM מהדרת את קובצי ה-.java ומדווחת על שגיאות התחביר שבהם. זה התפקיד של javac, שרץ לפני שה-JVM בכלל מתחילה. ה-JVM מקבלת קובצי .class מוכנים.
  • ה-JVM מספקת ממשק גרפי, מנהלת הרשאות קבצים של מערכת ההפעלה ומחלקת את ה-RAM בין כל התוכנות במחשב. ממשק גרפי מגיע מספריות, והרשאות וחלוקת זיכרון בין תהליכים הן עניין של מערכת ההפעלה. ה-JVM מנהלת את הזיכרון של התהליך שלה בלבד.
  • מאמת ה-bytecode דוחה קוד שמחלק באפס או ניגש לתא שמחוץ למערך. אלה בעיות של ערכים בזמן ריצה, והן מתגלות כחריגות כשהקוד רץ.
  • המאמת משווה את הקובץ לקוד המקור, ומסרב לקובץ בלי חתימה דיגיטלית. קוד המקור בכלל לא זמין לו, וחתימה איננה תנאי לטעינה. הוא בודק רק את הפקודות שבקובץ.
  • args[0] מחזיק את שם המחלקה. הוא מחזיק את הארגומנט הראשון שאחרי שם המחלקה.
  • לפני ש-main מתחילה, כל המחלקות של התוכנית כבר נטענו ואותחלו. רק המחלקה הראשית. כל השאר מאותחלות בשימוש הפעיל הראשון בהן.
  • משתנה מקומי שמחזיק הפניה נמצא בערמה, או שהאובייקט עצמו נמצא במחסנית. המשתנה, כולל ההפניה, במסגרת שעל המחסנית. האובייקט בערמה.
  • Class.forName רק טוען את המחלקה, וה-static initializer שלה לא רץ. כברירת מחדל הוא גם מאתחל אותה, ולכן הבלוק הסטטי רץ.
  • ClassLoader מותאם אישית חייב לפנות קודם להורה שלו. זו ברירת המחדל בלבד. טוען מותאם רשאי לחפש אצל עצמו קודם, ורק אחר כך לפנות להורה.
בדקו את עצמכם
java Report q1 q2 q3 q4: מה args.length, ומה args[3]?

4, ו-args[3] הוא "q4".

במחלקה Limits יש static final String UNIT = "kg"; ובלוק static שמדפיס הודעה. main מדפיסה את Limits.UNIT. האם ההודעה תודפס? ומה אם final יוסר?

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

קובץ class שהגיע מהרשת מכיל מתודה שמחלקת באפס. האם מאמת ה-bytecode ידחה אותו?

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

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

Interpreter ו-JIT: מפרש והידור בזמן ריצה

Interpreter: ביצוע תוך כדי קריאה

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

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

מה המפרש קורא? לפעמים טקסט מקור ממש, כמו סקריפט של shell שמבוצע שורה אחר שורה. ולפעמים קוד ביניים (bytecode): כך פועלים המפרש שבתוך HotSpot (ה-JVM הנפוצה) והלולאה המרכזית של CPython, שמבצעת את ה-bytecode של Python הוראה אחר הוראה.

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

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

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

כך נראה ה-bytecode ש-CPython מבצע עבור לולאה קטנה. המודול dis מציג אותו:

Python
import dis

def total_weight(boxes):
    w = 0
    for b in boxes:
        w += b          # the same few bytecodes are decoded on every pass
    return w

dis.dis(total_weight)
פלט
  3           RESUME                   0

  4           LOAD_SMALL_INT           0
              STORE_FAST               1 (w)

  5           LOAD_FAST_BORROW         0 (boxes)
              GET_ITER
      L1:     FOR_ITER                11 (to L2)
              STORE_FAST               2 (b)

  6           LOAD_FAST_BORROW_LOAD_FAST_BORROW 18 (w, b)
              BINARY_OP               13 (+=)
              STORE_FAST               1 (w)
              JUMP_BACKWARD           13 (to L1)

  5   L2:     END_FOR
              POP_ITER

  7           LOAD_FAST_BORROW         1 (w)
              RETURN_VALUE

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

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

עוד תכונה שנובעת מהביצוע תוך כדי: מפרש לא בודק את כל התוכנית לפני שהיא מתחילה. בשפה דינמית כמו Python, שגיאה בשורה מסוימת מתגלה רק ברגע שהביצוע מגיע אליה. בדוגמה הבאה הקובץ הוזן למפרש דרך הקלט הסטנדרטי (python - < late.py):

Python
def checkout(paid):
    print("cart ready")
    if paid:
        print("thank you")
    else:
        print(totl)     # typo: no such name

checkout(True)
checkout(False)
פלט
cart ready
thank you
cart ready
Traceback (most recent call last):
  File "<stdin>", line 9, in <module>
  File "<stdin>", line 6, in checkout
NameError: name 'totl' is not defined

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

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

"מהודרת" ו"מפורשת" הן תכונות של מימוש, לא של שפה. Java היא הדוגמה הטובה: javac מהדר את המקור ל-bytecode, ואז ה-JVM מריצה אותו בשתי דרכים יחד, גם מפרשת אותו וגם מהדרת ב-JIT את החלקים שרצים הרבה.
חזרה לתוכן העניינים

JIT: לתרגם פעם אחת את מה שרץ הרבה

JIT (Just-In-Time) הוא הידור שקורה בזמן הריצה עצמה: זמן הריצה לוקח bytecode (ב-Java) או IL (ב-.NET) ומתרגם אותו לקוד מכונה בזמן שהתוכנית כבר פועלת. המטרה אחת: ביצועים.

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

מתודה או לולאה שהמונה שלהן גבוה נחשבות "חמות", ורק אותן ה-JVM שולחת להידור לקוד מכונה מותאם. מכאן גם השם HotSpot: הנקודות החמות.

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

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

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

כדי לזהות JIT בשאלה, כדאי לדעת גם מה הוא לא:

  • הוא לא הידור מראש של כל התוכנית לפני ההרצה. לזה קוראים AOT (Ahead-Of-Time), כמו מהדר C.
  • הוא לא חלק מ-javac. javac רק מייצר bytecode; ה-JIT יושב בתוך ה-JVM.
  • הוא לא "מפרש משופר" שמפרש מהר יותר. הוא מהדר.
  • הוא לא איסוף אשפה, ואין לו קשר לשחרור זיכרון.
  • המתכנת לא מפעיל אותו: אין אנוטציה שמסמנת מתודה להידור, וכלי בנייה כמו Maven או Gradle לא מבצעים אותו. ה-JVM מחליטה לבד לפי המונים.

גם ב-.NET יש JIT, עם מדיניות אחרת: ה-CLR מתרגם מתודה לקוד מכונה ברגע שהיא נקראת לראשונה. החל מ-.NET Core 3.0 נוסף שם גם הידור מדורג, בדומה לרעיון של HotSpot שנראה מיד.

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

HotSpot: שני מהדרים, ושיבוץ של קריאה וירטואלית

ב-HotSpot פועלים שני מהדרי JIT, ומאז Java 8 הם עובדים כצוות כברירת מחדל. השיטה נקראת הידור מדורג (tiered compilation). אפשר לראות את הדגל ב-JVM של Java 8:

Bash
java -XX:+PrintFlagsFinal -version | grep TieredCompilation
פלט
     bool TieredCompilation                         = true                                {pd product}
מהדרמהירות ההידורעומק האופטימיזציהתפקיד נוסף
C1מהירקלאוסף פרופיל: אילו ענפים נלקחים, אילו טיפוסים מגיעים לכל קריאה
C2איטי יותרכבד ואגרסיבימהדר מחדש רק את הקוד החם ביותר, בעזרת הפרופיל ש-C1 אסף

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

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

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

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

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

שום דבר מזה לא נראה בקוד שכתבתם. קובץ ה-.java נשאר כפי שהיה, ומבחינת השפה הקריאה וירטואלית בדיוק כמו קודם: מחלקה שתיכתב מחר תוכל לדרוס את המתודה, וזה בדיוק המקרה שה-deoptimization מטפל בו.
תרחיש 22: מתודה שמתחממת, מתקררת ומתחממת שוב

שירות משלוחים ב-Java מחשב לכל הזמנה את המחיר במתודה quote, ובתוכה יש קריאה וירטואלית carrier.cost(weight).

  1. ההזמנות הראשונות: quote רצה במפרש, וה-JVM סופרת כל קריאה.
  2. המונה עובר את הסף: C1 מהדר את quote במהירות. השירות כבר מהיר יותר, ו-C1 רושם פרופיל.
  3. הפרופיל מגלה שכל הקריאות ל-carrier.cost הגיעו עד כה למחלקה TruckCarrier.
  4. quote נעשית אחת המתודות החמות ביותר, ו-C2 מהדר אותה מחדש. הפעם גוף TruckCarrier.cost משובץ בתוכה, ואין חיפוש בטבלת המתודות.
  5. בשלב מאוחר נטענת מחלקה חדשה DroneCarrier, והזמנה ראשונה עם רחפן מגיעה ל-quote. ההנחה נשברה: הקוד של C2 מבוטל, quote חוזרת למפרש, ואחרי שתצבור פרופיל חדש תהודר שוב.
  6. בלילה השירות מופעל מחדש. אין שום קוד מכונה בקובצי ה-class, ולכן כל הסיפור מתחיל שוב מהשלב הראשון.
טעויות נפוצות
  • C1 הוא המפרש של HotSpot, ו-C2 הוא המהדר. שניהם מהדרי JIT. ההבדל הוא במינון: C1 מהדר מהר ובקלות ואוסף פרופיל, C2 מהדר בכבדות ורק את הקוד החם ביותר.
  • ה-JIT ממיר מראש את כל ה-bytecode, עוד לפני הרצת השורה הראשונה. זה AOT. ה-JIT פועל בזמן הריצה, ורק על מה שהתברר כחם.
  • קוד המכונה נכתב לתוך קובץ ה-class כדי שההפעלה הבאה תהיה מהירה. הוא נשמר בזיכרון של התהליך בלבד (code cache) ונמחק כשהתהליך מסתיים.
  • ה-JIT מהדר את המתודה מחדש בכל קריאה וזורק את התוצאה בסופה. הוא מהדר פעם אחת ושומר את התוצאה לכל הקריאות הבאות.
  • שיבוץ של קריאה וירטואלית עלול לגרום לתוכנית לקרוא לגרסה הלא נכונה. השיבוץ הוא הנחה זהירה. כשמחלקה חדשה שוברת אותה, יש deoptimization וההתנהגות נשמרת.
  • מפרש מהיר יותר מקוד מהודר, כי הוא לא מבזבז זמן על הידור. ההפך: הוא איטי בגלל שהוא מפענח כל הוראה מחדש בכל פעם שהיא רצה.
בדקו את עצמכם
עמית מודד כמה זמן לוקחות 50 הקריאות הראשונות למתודה חדשה בשרת Java, ומסיק שהיא איטית מדי לייצור. מה הבעיה במדידה?

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

סקריפט Python שסוכם מספרים בלולאה של עשרה מיליון סיבובים איטי בהרבה מאותה לולאה בתוכנית C. למה?

CPython מפרש את ה-bytecode של הלולאה, ולכן ההוראות של גוף הלולאה מפוענחות מחדש בכל סיבוב. תוכנית ה-C הודרה מראש לקוד מכונה ואינה משלמת על פענוח.

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

קוד המכונה של ה-JIT חי רק בזיכרון של התהליך הקודם. התהליך החדש מתחיל במפרש ועובר שוב חימום.

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

Reflection: תוכנית שמסתכלת על עצמה

מה Reflection נותנת, ומה היא לא עושה

בקוד רגיל אתם כותבים t.calibrate("Noa"), והמהדר בודק כבר בהידור שהמתודה קיימת. Reflection (השתקפות) היא הדרך השנייה: התוכנית שואלת בזמן ריצה "אילו שדות, מתודות, בנאים ואנוטציות יש לטיפוס הזה?", ומשתמשת בתשובה.

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

כל זה קורה בזמן ריצה. Reflection לא בודקת דבר בזמן ההידור, ואין לה גישה לקוד המקור.

נשמע כמו Reflectionבפועל
לשנות את קובץ ה-.java ולהדר מחדשReflection לא נוגעת בקוד מקור ולא מפעילה מהדר
לכתוב מחדש את מה שמתודה קיימת עושהאפשר לקרוא למתודה, לא להחליף את הלוגיקה שלה
להחליף את מחלקת האב של אובייקט קייםההיררכיה של אובייקט קבועה
לתרגם bytecode לקוד מכונהזה תפקיד ה-JIT
למיין אוספיםאין לזה קשר; זה תפקיד של ספריות האוספים
חזרה לתוכן העניינים

ה-API ב-Java: Class, Field, Method

נקודת הכניסה היא אובייקט Class, ויש שלוש דרכים להשיג אותו: מאובייקט קיים עם obj.getClass(), משם שידוע בהידור עם Thermostat.class, ומשם שמגיע כמחרוזת בזמן ריצה עם Class.forName("Thermostat") (שם מלא כולל חבילה, אם יש).

מאובייקט ה-Class מבקשים חברים. ההבדל החשוב לזכור הוא בין שתי משפחות של מתודות:

קריאהמה היא מחזירהכולל private?כולל מה שהורש?
getMethods()המתודות הציבוריותלאכן, גם מהאב ומ-Object
getDeclaredMethods()כל מתודה שנכתבה במחלקה עצמה, כולל staticכןלא
getField(name)שדה public בשם הזה, גם אם הורשלאכן
getDeclaredField(name)כל שדה שהוגדר במחלקה עצמהכןלא

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

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

כדי לעקוף את הבדיקה מפעילים setAccessible(true) דרך ה-Field (או ה-Method) עצמו, ומאותו רגע אפשר גם לקרוא וגם לכתוב.

שאר הכלים: method.invoke(obj, args...) מפעיל מתודה על אובייקט, ו-getDeclaredConstructor().newInstance() יוצר אובייקט חדש. כשמבקשים מתודה בשם שלא קיים, getDeclaredMethod זורקת NoSuchMethodException. שימו לב שמתודה מזוהה לפי השם שלה יחד עם רשימת טיפוסי הפרמטרים.

תרחיש 23: לכוונן מבחוץ תרמוסטט סגור

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

Java
import java.lang.reflect.*;

class Thermostat {
    private int target = 21;
    private void calibrate(String tech) { System.out.println("calibrated by " + tech); }
    static void reset() { }
}

public class ThermoProbe {
    public static void main(String[] cli) throws Exception {
        Thermostat t = new Thermostat();
        Class<?> k = Class.forName("Thermostat");
        Field target = k.getDeclaredField("target");
        try { target.get(t); }                        // no setAccessible yet
        catch (IllegalAccessException e) { System.out.println("blocked: IllegalAccessException"); }
        target.setAccessible(true);                   // called on the Field, not on the Class
        target.set(t, 24);
        System.out.println("target now " + target.get(t));
        Method cal = k.getDeclaredMethod("calibrate", String.class);
        cal.setAccessible(true);
        cal.invoke(t, "Noa");
        try { k.getField("target"); }
        catch (NoSuchFieldException e) { System.out.println("getField(target): NoSuchFieldException"); }
        try { k.getDeclaredMethod("calibrat", String.class); }
        catch (NoSuchMethodException e) { System.out.println("typo: NoSuchMethodException"); }
        int declared = 0;
        for (Method m : k.getDeclaredMethods()) declared++;
        System.out.println("declared methods: " + declared);
        boolean inherited = false;
        for (Method m : k.getMethods()) if (m.getName().equals("hashCode")) inherited = true;
        System.out.println("hashCode in getMethods: " + inherited);
        inherited = false;
        for (Method m : k.getDeclaredMethods()) if (m.getName().equals("hashCode")) inherited = true;
        System.out.println("hashCode in getDeclaredMethods: " + inherited);
    }
}
פלט
blocked: IllegalAccessException
target now 24
calibrated by Noa
getField(target): NoSuchFieldException
typo: NoSuchMethodException
declared methods: 2
hashCode in getMethods: true
hashCode in getDeclaredMethods: false

עקבו אחרי הפלט לפי הסדר:

  1. השדה target נמצא עם getDeclaredField, אבל ה-get הראשון נחסם, כי עוד לא נקרא setAccessible.
  2. אחרי setAccessible(true) על ה-Field, אותו אובייקט שינה את הערך ל-24 וקרא אותו בחזרה.
  3. המתודה הפרטית calibrate הופעלה לפי השם וטיפוס הפרמטר שלה, אחרי setAccessible משלה.
  4. getField לא מצא את target, כי הוא מסתכל רק על שדות public.
  5. שגיאת כתיב בשם (calibrat) התגלתה רק בריצה, כ-NoSuchMethodException.
  6. getDeclaredMethods ספרה 2: הפרטית calibrate והסטטית reset. אין שם hashCode, כי היא הורשה מ-Object; ב-getMethods היא מופיעה.

ב-C# הרעיון זהה והשמות אחרים: Type במקום Class, שמשיגים עם GetType() או typeof(...); MethodInfo ו-FieldInfo במקום Method ו-Field; BindingFlags.NonPublic כדי לכלול חברים לא ציבוריים; ו-Activator.CreateInstance ליצירת מופע.

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

איפה Reflection עובדת בשבילכם

רוב המתכנתים משתמשים ב-Reflection בלי לכתוב אותה, דרך ספריות:

  • מסגרות בדיקה כמו JUnit ו-NUnit: הן עוברות בזמן ריצה על המתודות של מחלקת הבדיקות, מוצאות את אלה שמסומנות כבדיקה (אנוטציה ב-Java, attribute ב-C#) ומפעילות אותן אחת אחת.
  • בדיקות יחידה עצמן: כשצריך לבדוק או לעקוף מתודה או שדה פרטיים, Reflection נותנת אליהם גישה.
  • מכלי הזרקת תלויות (Dependency Injection), ספריות שממירות אובייקטים ל-JSON ובחזרה, ספריות ORM שממפות שדות לעמודות בטבלה, וכלי דיבוג שמציגים את תוכן האובייקטים.

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

Java
import java.util.Properties;
import java.io.StringReader;

interface Exporter { String export(String data); }

class CsvExporter implements Exporter {
    public String export(String data) { return data.replace(' ', ','); }
}

public class PluginHost {
    public static void main(String[] cli) throws Exception {
        Properties conf = new Properties();
        conf.load(new StringReader("exporter=CsvExporter"));   // stands in for a config file
        String name = conf.getProperty("exporter");
        Class<?> cls = Class.forName(name);                     // unknown when Main was compiled
        Exporter ex = (Exporter) cls.getDeclaredConstructor().newInstance();
        System.out.println(ex.export("id name score"));
    }
}
פלט
id,name,score

שימו לב לחלוקת העבודה: Reflection נדרשת רק לטעינה וליצירה. מהרגע שיש מופע, ההמרה ל-Exporter מחזירה אותנו לקוד רגיל שהמהדר בודק.

ומתי לא? נניח שהאפליקציה תמיד מייצאת ל-CSV: אז אין סיבה לקרוא את השם מקובץ, וכותבים Exporter ex = new CsvExporter();, קריאה ישירה ומהירה שהמהדר בודק. Reflection שמורה למחלקות שהזהות שלהן נודעת רק בזמן ריצה.

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

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

המחיר: מהירות, הסתרה ושמות כמחרוזות

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

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

חלופה מהירה יותר קיימת מ-Java 7: MethodHandle מהחבילה java.lang.invoke. זו הפניה מוקלדת (typed) למתודה. בדיקת ההרשאות נעשית פעם אחת, כשיוצרים אותה דרך Lookup, וה-JIT מסוגל לשבץ אותה (inline) במקום הקריאה, כך שהקריאה מהירה יותר:

Java
import java.lang.invoke.*;

public class HandleDemo {
    public static void main(String[] cli) throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();           // access checked here, once
        MethodType type = MethodType.methodType(String.class, int.class);
        MethodHandle tail = lookup.findVirtual(String.class, "substring", type);
        String s = (String) tail.invokeExact("ticket-4471", 7);         // an instance method
        System.out.println(s);
    }
}
פלט
4471

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

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

עם זאת, הפגיעה מקומית: setAccessible(true) פותח רק את אובייקט ה-Field או ה-Method שעליו נקרא. השדה לא נעשה ציבורי לשאר הקוד, ושום דבר לא משתנה באופן קבוע.

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

תרחיש 24: כלי טשטוש שובר קריאה לפי שם

אפליקציה מפעילה מתודה בשם applyVoucher דרך getDeclaredMethod("applyVoucher", int.class). לפני ההפצה מריצים עליה כלי טשטוש (obfuscator), ProGuard למשל, שמקצר שמות כדי להקטין ולהסתיר את הקוד, ו-applyVoucher הופכת ל-b.

בהרצה, החיפוש לפי השם הישן נכשל עם NoSuchMethodException. ה-JVM לא שומרת בשום מקום את השם המקורי, ולכן אין לה מה להשוות אליו.

למה לא ClassNotFoundException? כי המחלקה עצמה קיימת; רק שם המתודה השתנה. התיקון: להגדיר לכלי הטשטוש כלל ששומר את השם של המתודות שנקראות דרך Reflection.

טעויות נפוצות
  • getDeclaredMethods מחזירה רק את המתודות הציבוריות של המחלקה. היא מחזירה כל מתודה שנכתבה במחלקה, בלי סינון: לא לפי הרשאה, לא לפי static ולא לפי אנוטציה. מה שחסר בה הוא רק מה שהורש.
  • getField מוצא גם שדה פרטי. רק שדות public. לשדה פרטי צריך getDeclaredField.
  • Reflection מתעלמת מ-private, אז מספיק למצוא את השדה. בלי setAccessible(true) הגישה נחסמת עם IllegalAccessException.
  • מפעילים setAccessible(true) פעם אחת על ה-Class, וכל המחלקה נפתחת. הוא נקרא על Field או Method מסוים, ופותח רק אותו.
  • דרך Reflection אפשר לקרוא שדה פרטי אבל לא לשנות אותו. אפשר גם set, כמו שראיתם בתרמוסטט.
  • Reflection מאמתת את מבנה המחלקות כבר בהידור. היא פועלת רק בזמן ריצה, ולכן שגיאות שם מתגלות רק אז.
  • כשמחפשים מתודה, השם לא חשוב, רק טיפוסי הפרמטרים. החיפוש דורש את השם וגם את טיפוסי הפרמטרים.
בדקו את עצמכם
המחלקה Invoice יורשת מ-Document, שבה מוגדרת public void print(). האם print תופיע במערך ש-Invoice.class.getDeclaredMethods() מחזירה? ובמערך של getMethods()?

ב-getDeclaredMethods לא, כי היא נכתבה ב-Document ולא ב-Invoice. ב-getMethods כן, כי היא ציבורית וירושה נכללת שם.

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

Class.forName(שם) ואחר כך getDeclaredConstructor().newInstance(). את התוצאה ממירים לממשק ידוע שהמחלקה מממשת, ומשם קוראים למתודות כרגיל.

לולאה חמה מפעילה מתודה דרך Method.invoke מיליוני פעמים. מה שני צעדים שיקצרו את זמן הריצה?

לשמור את אובייקט ה-Method פעם אחת במקום לחפש אותו בכל סיבוב, או לעבור ל-MethodHandle, שההרשאות שלו נבדקות פעם אחת וה-JIT יכול לשבץ אותו.

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

Garbage collector: מי מפנה את הערמה

נגישות: הכלל שקובע מה נחשב זבל

בסביבות ריצה מנוהלות, כמו ה-JVM וה-CLR של .NET, המתכנת לא משחרר אובייקטים בעצמו. את העבודה הזו עושה Garbage collector (אספן זבל, GC): מנגנון אוטומטי שמחזיר לערמה את הזיכרון של אובייקטים שכבר אין דרך להגיע אליהם.

השאלה שה-GC שואל היא לא "האם משתמשים באובייקט?" אלא "האם אפשר להגיע אליו?". נקודות המוצא נקראות שורשים (GC roots), ואובייקט שאין אליו שום שרשרת הפניות מאף שורש הוא זבל.

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

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

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

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

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

מתי האיסוף קורה, ו-System.gc()

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

כך גם כשהמשתנה היחיד שהצביע על האובייקט יוצא מהתחום (scope): המשתנה נעלם, האובייקט נשאר בערמה עד האיסוף הקרוב. אין שעון שאוסף אובייקט "אחרי כך וכך דקות", וה-GC גם לא מחכה שמישהו יבקש ממנו לרוץ.

ומה עם System.gc()? זו בקשה בלבד: היא אומרת ל-JVM "זה זמן טוב לאסוף", וה-JVM רשאית להתעלם.

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

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

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

אלגוריתמים, דורות, עצירות ואספנים

אלגוריתםמה הוא עושה עם החייםמה הוא עושה עם המתים
mark-and-sweepמסמן אותם ומשאיר במקוםמשחרר את המקום שלהם
mark-compactמסמן ומזיז אותם צמוד זה לזה, כדי שלא יישארו חורים (פיצול)המקום שלהם נבלע בשטח הפנוי הרציף
copyingמעתיק אותם לאזור אחרכל האזור הישן מתפנה בבת אחת

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

ב-HotSpot הערמה מחולקת בהתאם. הדור הצעיר בנוי מ-Eden, שבו נולדים האובייקטים, ומשני אזורי survivor. הוא נאסף לעתים קרובות באיסוף קטן (minor GC), והאיסוף שם זול ומשתלם: רוב מה שיש שם כבר מת, ולכן מעט עבודה משחררת הרבה זיכרון.

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

גם הדור הצעיר וגם הדור הישן נמצאים בערמה; אף אחד מהם לא במחסנית. ב-.NET החלוקה דומה, עם שלושה דורות: 0, 1 ו-2.

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

אספן ב-HotSpotאיך הוא אוסףמתי בוחרים בו
Serialעוצר את האפליקציה ועובד ב-thread אחדמכונות קטנות, ערמות קטנות
Parallelעוצר את האפליקציה ועובד בכמה threads במקבילכשהמטרה היא תפוקה כוללת מקסימלית
G1מחלק את הערמה לאזורים (regions) רביםברירת המחדל מאז Java 9 במכונות בתצורת שרת
ZGC, Shenandoahרוב העבודה מתבצעת בזמן שהאפליקציה רצהכשצריך עצירות קצרות מאוד

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

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

Soft, Weak ו-Phantom

הפניה רגילה, כמו Image img = load();, היא הפניה חזקה (strong): כל עוד יש אחת כזו בשרשרת משורש, האובייקט נגיש ונשאר. החבילה java.lang.ref מוסיפה שלוש דרגות חלשות יותר, שמאפשרות להחזיק אובייקט בלי למנוע ממנו להיאסף:

הפניהמתי האובייקט נאסףמה get() מחזירהלשם מה
SoftReferenceרק כשהזיכרון נלחץ. כל ההפניות האלה מנוקות לפני שנזרקת OutOfMemoryErrorאת האובייקט, עד שנוקתהCache
WeakReferenceבאיסוף הראשון שמגלה שאין אליו אף הפניה חזקהאת האובייקט, עד שנוקתהמיפויים שאסור להם להשאיר אובייקטים בחיים
PhantomReferenceאחרי שהאובייקט כבר בלתי נגישתמיד nullלקבל הודעה שהאובייקט מת ולנקות משאבים דרך ReferenceQueue
Java
import java.lang.ref.*;

public class RefKinds {
    public static void main(String[] cli) {
        ReferenceQueue<Object> queue = new ReferenceQueue<>();
        Object photo = new Object();
        SoftReference<Object> soft = new SoftReference<>(photo);
        WeakReference<Object> weak = new WeakReference<>(photo);
        PhantomReference<Object> ghost = new PhantomReference<>(photo, queue);
        System.out.println("soft.get() is null? " + (soft.get() == null));
        System.out.println("weak.get() is null? " + (weak.get() == null));
        System.out.println("ghost.get() is null? " + (ghost.get() == null));   // even while photo is alive
    }
}
פלט
soft.get() is null? false
weak.get() is null? false
ghost.get() is null? true

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

למה Cache של תוצאות כבדות מחזיק SoftReference ולא WeakReference? כי Soft שורדת עד שבאמת חסר זיכרון, ולכן הערכים נשארים זמינים זמן רב. Weak עלולה להתנקות כבר באיסוף הקטן הבא, וה-Cache יתרוקן כל הזמן.

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

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

על PhantomReference בנויה המחלקה Cleaner, והיא הדרך המומלצת היום לניקוי כזה, במקום finalize().
חזרה לתוכן העניינים

דליפות זיכרון, משאבים ו-finalizer

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

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

תרחיש 25: יומן ביקורת שאוכל את הערמה

שירות שומר צילום מצב לכל פעולה במפה סטטית. הוא הורץ כאן עם java -Xmx32m AuditTrail, ערמה קטנה בכוונה כדי להגיע לסוף מהר:

Java
import java.util.*;

public class AuditTrail {
    static final Map<Long, long[]> AUDIT_TRAIL = new HashMap<>();   // static field = GC root
    static long seq = 0;

    static void record() {
        long[] snapshot = new long[250_000];        // about 2 MB
        AUDIT_TRAIL.put(seq++, snapshot);           // every key is new, nothing is ever removed
    }

    public static void main(String[] cli) {
        while (true) record();
    }
}
פלט
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at AuditTrail.record(AuditTrail.java:8)
	at AuditTrail.main(AuditTrail.java:13)

הניתוח: AUDIT_TRAIL הוא שדה סטטי, כלומר שורש. כל מערך שנכנס למפה נגיש דרכו, והמפתח תמיד חדש, כך שאף רשומה לא מוחלפת. ה-GC רץ שוב ושוב ולא מוצא מה לשחרר, עד שהערמה מלאה גם אחרי איסוף וה-JVM זורקת OutOfMemoryError: Java heap space.

ב-heap dump של התהליך הייתה נראית השרשרת המלאה: השדה הסטטי, אחריו ה-HashMap והרשומות שלו, ובקצה כל מערכי ה-long[] שנצברו.

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

ב-.NET המקבילה היא OutOfMemoryException.

איך מאתרים דליפה בפועל? מפיקים heap dump, צילום של כל הערמה, ובכלי ניתוח בודקים, עבור האובייקטים שמצטברים, מאיזה GC root מגיעה אליהם השרשרת. השרשרת הזו מצביעה על הקוד שמחזיק.

מה מנסיםלמה זה לא עובד
לחפש אובייקטים שאין אליהם שום הפניהאובייקט בלי הפניות לא דולף, ה-GC מפנה אותו בעצמו. מחפשים דווקא את מה שעדיין מחובר
להגדיל את -Xmxהערמה הגדולה תתמלא גם היא; רק דוחים את הקריסה
לקרוא ל-System.gc() שוב ושובשום איסוף לא משחרר אובייקט נגיש

ה-GC מנהל זיכרון ותו לא. קובץ פתוח, socket או מנעול לא נסגרים כשהאובייקט נאסף, ולא כדאי לחכות לזה. משאבים כאלה משחררים במקום ידוע מראש: ב-Java עם try-with-resources, וב-C# עם using, שקורא ל-Dispose.

ב-C# קל להתבלבל: התחביר ~ReportFile() מזכיר destructor של C++, אבל זה finalizer. את ה-finalizers מריץ thread נפרד שמוקדש לכך (finalizer thread), בזמן שה-GC מחליט עליו: לא ברגע שנעלמת ההפניה האחרונה ולא ביציאה מהבלוק, ולכן הוא לא מתאים לסגירה של קובץ בזמן.

C#
using System;

class ReportFile : IDisposable
{
    public void Dispose() => Console.WriteLine("Dispose: file closed");
    ~ReportFile() => Console.WriteLine("finalizer ran");   // timing chosen by the GC
}

class Program
{
    static void Main()
    {
        using (var f = new ReportFile())
        {
            Console.WriteLine("writing report");
        }                                                  // Dispose runs right here
        Console.WriteLine("after using block");
    }
}
פלט
writing report
Dispose: file closed
after using block

בהרצה, השורה Dispose: file closed הודפסה מיד ביציאה מבלוק ה-using, לפני after using block. ההודעה של ה-finalizer לא הופיעה בפלט בכלל עד שהתהליך הסתיים: אין לדעת מתי, ואם בכלל, היא תרוץ.

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

טעויות נפוצות
  • ה-GC סופר כמה הפניות יש לכל אובייקט, ואובייקט עם אפס הפניות הוא מה שנאסף. הוא בודק נגישות מהשורשים. לכן גם קבוצת אובייקטים שמצביעים זה על זה נאספת, כשאף שורש לא מגיע אליה.
  • ברגע שהמשתנה האחרון יוצא מהתחום, הזיכרון של האובייקט משתחרר. האובייקט רק הופך זכאי לאיסוף, והוא נשאר בערמה עד שה-GC ירוץ.
  • בשפה עם GC אי אפשר לדלוף זיכרון. אפשר, כשמשאירים הפניות לאובייקטים שכבר לא צריך, למשל באוסף סטטי.
  • קריאה ל-System.gc() מפנה את הזיכרון מיד. היא בקשה שה-JVM רשאית לדחות או להתעלם ממנה.
  • ה-GC סוגר קבצים שהתוכנית שכחה לסגור. הוא מטפל בזיכרון בלבד. קבצים סוגרים עם try-with-resources או using.
  • Parallel עוצר את האפליקציה, ו-Serial אוסף לצידה בלי לעצור. שניהם עוצרים. Serial עושה את האיסוף ב-thread אחד, Parallel בכמה.
  • הדור הישן לא נאסף, והדור הצעיר יושב במחסנית. שני הדורות בערמה, ושניהם נאספים; הישן פשוט נאסף בתדירות נמוכה יותר.
  • PhantomReference נותנת את האובייקט ב-get() כדי לנקות אותו. get() שלה מחזירה תמיד null. הניקוי מתבסס על ההודעה דרך ReferenceQueue.
  • finalizer ב-C# רץ בדיוק כשהאובייקט יוצא משימוש, כמו destructor ב-C++. הוא רץ ב-finalizer thread בזמן שה-GC בוחר, ואולי בכלל לא לפני סוף התהליך.
בדקו את עצמכם
בגרף של רשת חברתית, הצומת של Dana מצביע על Omer וזה של Omer מצביע על Dana. אחרי מחיקה מהאינדקס, אף משתנה ואף שדה סטטי לא מצביעים על אף אחד מהם. מה יקרה להם באיסוף הבא?

שניהם ייאספו. ההפניות ההדדיות לא משנות, כי שום שרשרת מאף GC root לא מגיעה אליהם.

Cache של עמודים מעובדים מחזיק את הערכים ב-WeakReference, ושיעור הפגיעה בו נמוך מאוד. מה ההסבר ומה התיקון?

WeakReference מתנקה כבר באיסוף הקרוב שבו אין על הערך הפניה חזקה, ולכן העמודים נעלמים מהר. SoftReference שומרת אותם עד שיש לחץ זיכרון ומתאימה ל-Cache.

שירות נופל אחרי שבוע ריצה, וביומן מופיעה השגיאה OutOfMemoryError: Java heap space. מה הצעד הראשון לאיתור הסיבה?

להפיק heap dump ולחפש בו את האובייקטים שמצטברים ואת שרשרת ההפניות שמחברת אותם ל-GC root.

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

Mutex: מנעול לבעלים אחד

הבעיה ש-Mutex פותר: תנאי מירוץ

חשבו על חדר הלבשה בחנות עם מפתח אחד שתלוי על וו. מי שלוקח את המפתח נכנס; מי שמגיע אחריו עומד בתור עד שהמפתח חוזר לוו. Mutex (קיצור של Mutual Exclusion, מניעה הדדית) הוא בדיוק המפתח הזה: מנעול שבכל רגע נתון נמצא בידי thread אחד לכל היותר.

thread שמנסה לרכוש Mutex תפוס לא מקבל סירוב ולא מסתובב בלולאה שבודקת שוב ושוב (busy wait). הוא נחסם: מערכת ההפעלה משעה אותו בלי לצרוך זמן מעבד, ומעירה אותו כשהמנעול מתפנה.

הקוד שהמנעול שומר עליו נקרא קטע קריטי (critical section): הקטע שבו נוגעים במשאב משותף. בלי שמירה כזו מקבלים תנאי מירוץ (Race Condition), מצב שבו התוצאה תלויה בסדר המקרי שבו ה-threads משתלבים זה בזה.

הדוגמה הקלאסית היא seatsSold++. נראה כמו פעולה אחת, אבל אלה שלוש: לקרוא את הערך, להוסיף אחד, לכתוב בחזרה. אם שני threads קוראים 41 באותו רגע, שניהם כותבים 42, ומושב אחד נעלם מהספירה.

תרחיש 26: שתי קופות מוכרות כרטיסים

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

Java
public class BoxOffice {
    private static long seatsSold = 0;
    private static final Object BOOTH = new Object();

    public static void main(String[] cli) throws InterruptedException {
        Runnable agent = () -> {
            for (int n = 0; n < 1_000_000; n++) {
                synchronized (BOOTH) {      // one agent at a time inside
                    seatsSold++;            // read, add, write
                }
            }
        };
        Thread east = new Thread(agent);
        Thread west = new Thread(agent);
        east.start(); west.start();
        east.join(); west.join();
        System.out.println("seats sold: " + seatsSold);
    }
}
פלט
seats sold: 2000000

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

בלי ה-synchronized אין שום הבטחה. כשהבלוק הוסר והתוכנית הורצה כאן ארבע פעמים, פעמיים יצא 2000000, ופעמיים פחות: 1999719 ו-1185755. תוצאה שמשתנה מהרצה להרצה, ולפעמים נכונה במקרה, היא הסימן המובהק לתנאי מירוץ.

לכל Mutex יש בעלים (ownership): ה-thread שרכש אותו הוא היחיד שרשאי לשחרר אותו. נחזור לזה בדוגמאות של Java ושל C#.

Mutex לא...מה כן
נותן לכל thread עותק פרטי של המשאביש משאב אחד, והגישה אליו עוברת בתור
מאפשר לכמה כותבים, או לכמה קוראים, להיות בפנים יחדרק אחד בפנים, בלי קשר למה שהוא עושה
מאיץ את התוכניתהוא מוסיף המתנה; התמורה היא נכונות
מעדיף threads בעדיפות גבוההאין לו מדיניות עדיפויות
משחרר זיכרוןזה תפקיד ה-GC
חזרה לתוכן העניינים

Java: synchronized ו-ReentrantLock

ב-Java לא תמצאו מחלקה בשם Mutex. במקום זה, כל אובייקט נושא איתו מנעול פנימי (monitor), והמילה synchronized משתמשת בו:

צורהאיזה מנעול נלקח
מתודת מופע synchronizedשל this
מתודה static synchronizedשל אובייקט ה-Class של המחלקה
בלוק synchronized (obj)של obj

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

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

Java
public class Wallet {
    private int balance = 300;

    synchronized void withdrawAll() {        // takes the lock on this
        System.out.println("withdrawAll holds the lock");
        log("withdrew " + balance);          // asks for the same lock again
        balance = 0;
    }

    synchronized void log(String line) {
        System.out.println("log: " + line);
    }

    public static void main(String[] cli) {
        new Wallet().withdrawAll();
        System.out.println("no deadlock");
    }
}
פלט
withdrawAll holds the lock
log: withdrew 300
no deadlock

withdrawAll כבר מחזיקה את המנעול של האובייקט, ו-log מבקשת את אותו מנעול. מכיוון שזה אותו thread, הבקשה נענית מיד. אין Deadlock, אין חריגה, וזה גם מתקמפל בלי שום בעיה.

כשצריך שליטה רבה יותר, יש את java.util.concurrent.locks.ReentrantLock, מנעול מפורש (וגם הוא reentrant):

  • lock() ו-unlock() נקראים במפורש, ולכן unlock תמיד יושב ב-finally. היתרון: השחרור בידיים שלכם ולא קשור לגבולות של בלוק אחד.
  • tryLock() מנסה לרכוש בלי להיחסם בכלל, ו-tryLock(זמן, יחידה) מחכה לכל היותר פרק זמן מוגבל. שתיהן מחזירות true או false.
  • lockInterruptibly() ממתין למנעול, אבל אפשר לקטוע את ההמתנה: כש-thread אחר קורא ל-interrupt() על הממתין, ההמתנה נגמרת ונזרקת InterruptedException. זו חריגה checked, ולכן חייבים לתפוס אותה או להצהיר עליה.
  • הגינות (fairness): new ReentrantLock(true) מעביר את המנעול ל-thread שממתין הכי הרבה זמן.

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

תרחיש 27: מדפסת משותפת: ניסיון, ויתור וזר

main מחזיק מנעול הוגן של מדפסת, ושלושה threads מנסים את מזלם:

Java
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class PrinterQueue {
    public static void main(String[] cli) throws Exception {
        ReentrantLock printer = new ReentrantLock(true);   // fair: longest waiter goes first
        printer.lock();                                     // main owns the lock
        try {
            Thread quick = new Thread(() -> {
                boolean got = printer.tryLock();            // do not block at all
                System.out.println("tryLock: " + got);
                try {
                    got = printer.tryLock(100, TimeUnit.MILLISECONDS);
                    System.out.println("tryLock with timeout: " + got);
                } catch (InterruptedException e) { }
            });
            quick.start(); quick.join();

            Thread patient = new Thread(() -> {
                try {
                    printer.lockInterruptibly();
                    System.out.println("patient printed");
                } catch (InterruptedException e) {           // checked: must be caught or declared
                    System.out.println("patient gave up: InterruptedException");
                }
            });
            patient.start();
            Thread.sleep(150);
            patient.interrupt();
            patient.join();

            Thread intruder = new Thread(() -> {
                try { printer.unlock(); }
                catch (IllegalMonitorStateException e) { System.out.println("intruder: IllegalMonitorStateException"); }
            });
            intruder.start(); intruder.join();
        } finally {
            printer.unlock();                               // always in finally
        }
        System.out.println("still locked? " + printer.isLocked());
    }
}
פלט
tryLock: false
tryLock with timeout: false
patient gave up: InterruptedException
intruder: IllegalMonitorStateException
still locked? false
  1. quick משתמש ב-tryLock() ומקבל false מיד, ואז מחכה 100 מילישניות עם tryLock עם זמן, ושוב מקבל false. הוא אף פעם לא נתקע.
  2. patient נחסם בתוך lockInterruptibly(). כש-main קורא ל-interrupt() עליו, ההמתנה נקטעת והוא נכנס ל-catch של InterruptedException, בלי לקבל את המנעול.
  3. המנעול זוכר ש-main הוא הבעלים שלו. לכן כש-intruder קורא ל-unlock(), הבקשה נדחית מיד עם IllegalMonitorStateException.
  4. רק הבעלים, main, משחרר ב-finally, ואז isLocked() מחזיר false.
volatile אינו תחליף ל-Mutex. הוא מבטיח שכל thread יראה את הערך העדכני של המשתנה (נראות), אבל לא הופך את שלושת השלבים של seatsSold++ לפעולה אחת שאי אפשר לקטוע (אטומיות).
חזרה לתוכן העניינים

C#: lock מול System.Threading.Mutex

ב-C# יש שני כלים בשם דומה ובמשקל שונה מאוד. הכלי היומיומי הוא lock (obj) { ... }, שהמהדר פורש ל-Monitor.Enter ול-Monitor.Exit עטופים ב-try ו-finally.

הטווח שלו הוא התהליך הנוכחי בלבד, ובדומה ל-synchronized ב-Java, thread שכבר מחזיק בו יכול להיכנס אליו שוב.

C#
private readonly object _cartGuard = new object();   // dedicated, never exposed

public void AddItem(string sku)
{
    lock (_cartGuard)          // Monitor.Enter ... try { } finally { Monitor.Exit }
    {
        _items.Add(sku);
    }
}

נועלים על אובייקט ייעודי, private readonly, שאף אחד מחוץ למחלקה לא רואה. לא על this, לא על typeof(...) ולא על מחרוזת, כי אליהם יכול להגיע גם קוד זר ולנעול עליהם בלי לדעת, וכך ליצור חסימות שאף אחד לא תכנן.

הכלי השני הוא System.Threading.Mutex, אובייקט של מערכת ההפעלה. הוא כבד יותר, אבל אפשר לתת לו שם ולחלוק אותו בין תהליכים נפרדים. שימוש מוכר: לוודא שרק עותק אחד של אפליקציה רץ במחשב. רוכשים עם WaitOne() ומשחררים עם ReleaseMutex(), וגם כאן לשחרור יש בעלים:

C#
using System;
using System.Threading;

class Program
{
    static void Main()
    {
        var gate = new Mutex();
        gate.WaitOne();                                    // main thread now owns it
        var stranger = new Thread(() =>
        {
            try { gate.ReleaseMutex(); }
            catch (ApplicationException e) { Console.WriteLine("non-owner: " + e.GetType().Name); }
        });
        stranger.Start(); stranger.Join();
        gate.ReleaseMutex();                               // the owner may release
        Console.WriteLine("owner released");
    }
}
פלט
non-owner: ApplicationException
owner released

ה-thread הזר שניסה לשחרר קיבל ApplicationException, וה-thread הראשי, שהוא הבעלים, שחרר בלי בעיה.

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

Deadlock, Starvation ומה Semaphore עושה אחרת

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

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

Java
// thread 1: moves stock, then books it      // thread 2: books first, then moves stock
synchronized (inventory) {                    synchronized (ledger) {
    synchronized (ledger) {                       synchronized (inventory) {   // both wait here
        ...                                           ...
    }                                             }
}                                             }

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

בעיהמה רואיםהאם ה-threads חסומים?
Deadlockשני threads או יותר מחכים זה לזה במעגלכן, לתמיד
Livelockthreads משחררים ותופסים שוב בתגובה זה לזה, ושום דבר לא מתקדםלא, הם עסוקים כל הזמן
Priority Inversionthread בעדיפות נמוכה מחזיק מנעול ש-thread בעדיפות גבוהה צריךהגבוה מחכה לנמוך
Race Conditionתוצאה שתלויה בשילוב המקרי של ה-threads בגישה לנתוניםלא; כאן הבעיה היא דווקא חוסר במנעול
Starvationthread מסוים מפסיד שוב ושוב, ואחרים תמיד מקבלים את המנעול לפניורק הוא, והוא עדיין עשוי להתקדם מתישהו

לסדר נעילה לא מתואם התוצאה הקלאסית היא Deadlock, לא Livelock ולא תנאי מירוץ. ומנעול הוא התרופה לתנאי מירוץ, לא הגורם שלו.

נגד Starvation (הרעבה) משתמשים במנעול הוגן (Fair Lock), למשל ReentrantLock שנבנה עם fairness=true, שנותן את המנעול לפי סדר ההמתנה בתור. להגדיל את מספר הניסיונות האקראיים לא מבטיח כלום, ו-synchronized לא יעזור כאן, כי הוא לא מבטיח לממתינים שום סדר.

Semaphore נראה דומה ל-Mutex, אבל הוא סופר היתרים (permits) במקום להחזיק בעלים אחד. כל רכישה מורידה היתר, כל שחרור מוסיף, ו-thread שמבקש כשאין היתרים נחסם. וכל thread רשאי לשחרר, גם אם לא רכש:

Java
import java.util.concurrent.Semaphore;

public class Lanes {
    public static void main(String[] cli) throws Exception {
        Semaphore lanes = new Semaphore(3);       // up to 3 holders at once
        lanes.acquire();
        lanes.acquire();
        System.out.println("free lanes: " + lanes.availablePermits());
        Thread other = new Thread(() -> lanes.release());   // a thread that never acquired
        other.start(); other.join();
        System.out.println("free lanes after release by another thread: " + lanes.availablePermits());
    }
}
פלט
free lanes: 1
free lanes after release by another thread: 2
MutexSemaphore
כמה בפנים בבת אחתthread אחדעד מספר ההיתרים
מי משחרררק ה-thread שרכשכל thread
למה משמשגישה בלעדית למשאב משותףתקרה על מספר המשתמשים בו-זמנית במשאב

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

טעויות נפוצות
  • Mutex מאפשר למספר קבוע מראש של threads לעבוד יחד על המשאב. זה מה ש-Semaphore עושה. Mutex מכניס תמיד רק אחד.
  • כל thread יכול לשחרר Mutex שמישהו אחר נעל. רק הבעלים. ב-Java נזרקת IllegalMonitorStateException, וב-C# ApplicationException.
  • מתודה synchronized שקוראת למתודה synchronized של אותו אובייקט נתקעת או זורקת חריגה. המנעול reentrant, וה-thread שמחזיק בו נכנס שוב בלי להמתין.
  • גם ל-synchronized יש tryLock ומצב הוגן. אלה יכולות של ReentrantLock בלבד.
  • אחרי interrupt, thread שממתין ב-lockInterruptibly ממשיך לחכות עד שיקבל את המנעול. ההמתנה נקטעת, והוא מקבל InterruptedException.
  • כשנועלים כמה מנעולים בסדרים שונים, הסכנה היא Livelock או תנאי מירוץ. הסכנה הקלאסית היא Deadlock: כל אחד מחזיק את מה שהשני צריך.
  • עדיף לחכות בלולאה שבודקת את המנעול מאשר להיחסם. בדיקה עסוקה שורפת זמן מעבד. Mutex חוסם את הממתין, והוא לא צורך מעבד עד שמעירים אותו.
  • מספיק לסמן את המונה כ-volatile כדי להגן על count++. volatile נותן נראות בלבד. הקריאה, ההוספה והכתיבה עדיין יכולות להתערבב.
בדקו את עצמכם
אולם כושר מאפשר לכל היותר 25 מתאמנים בו-זמנית, ותוכנית מנהלת את הכניסה בעזרת threads. באיזה כלי תשתמשו?

Semaphore עם 25 היתרים. Mutex היה מכניס מתאמן אחד בלבד.

המתודה swap(Locker a, Locker b) נועלת את a ואז את b. thread אחד קורא swap(x, y) ובאותו זמן אחר קורא swap(y, x), ומדי פעם המערכת קופאת. מה התיקון?

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

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

זו הרעבה. מחליפים למנעול הוגן, new ReentrantLock(true), שמעביר את המנעול לממתין הוותיק ביותר.

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

סיכום

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

מושגבקצרהמה לזכור למבחן
Singletonמחלקה עם מופע אחד ודרך גישה אחת אליו מכל התוכניתהבנאי private. בטיחות ל-threads מגיעה משדה static final, ממחלקת Holder, מ-enum או מ-synchronized
Constructorקוד שמכין אובייקט חדש בזמן newאין לו טיפוס החזרה. בנאי ברירת מחדל נוצר רק כשלא נכתב אף בנאי, ובנאי האב רץ ראשון
protectedהרשאה שפותחת את החבר ליורשותב-Java הוא פתוח גם לכל החבילה; ב-C# רק למחלקה וליורשות שלה
Interfaceחוזה של מתודות בלי מצבלמחלקה אחת מותר לממש כמה ממשקים בלי הגבלה. שדות בממשק הם public static final, ומתודות default ו-static קיימות מ-Java 8
Polymorphismהפניה מטיפוס כללי שמאחוריה מימושים שוניםהמהדר בודק לפי הטיפוס המוצהר, והריצה בוחרת לפי האובייקט. העמסה נקבעת כבר בהידור
Virtual functionמתודה שהגרסה שלה נקבעת בריצה לפי האובייקטב-Java מתודות מופע וירטואליות כברירת מחדל. ב-C# צריך virtual ו-override, ו-new רק מסתירה
IComparableהסדר הטבעי של טיפוס ב-C#CompareTo מחזירה מספר שלילי, 0 או חיובי, ורק הסימן קובע. המקבילה ב-Java היא Comparable
By valueהפונקציה מקבלת עותק של הארגומנטעבור אובייקט מועתקת ההפניה, ולכן השמה מחדש בתוך הפונקציה לא נראית אצל הקורא. ב-C# יש ref ו-out
Recursionפונקציה שקוראת לעצמהחייב תנאי עצירה. כל קריאה פותחת מסגרת במחסנית, עומק רב מסתיים ב-StackOverflowError, ו-Java לא מבטלת קריאות זנב
Exceptionאובייקט שגיאה שעולה במחסנית עד catch מתאיםחריגה checked מחייבת catch או throws. finally רץ תמיד, ו-try-with-resources סוגר את המשאב לפני ה-catch
Bytecodeקוד הביניים שבקובצי ה-classנייד בין מערכות, אינו קוד מכונה, וקל לפענח אותו חזרה
JVMהמכונה שטוענת, מאמתת ומריצה bytecodeמנהלת זיכרון, GC ו-threads. היא עצמה תלויה בפלטפורמה, ומאמתת את הקוד לפני ההרצה
mainהמקום שבו התוכנית מתחילההחתימה public static void main(String[] args). ב-args אין את שם התוכנית, והאתחול הסטטי של המחלקה הראשית רץ לפני main
Interpreterמבצע את הקוד הוראה אחר הוראה תוך כדי ריצהמתחיל מיד, אבל איטי, כי כל הוראה מפוענחת מחדש בכל ביצוע
JITמהדר לקוד מכונה בזמן הריצהרק את הקוד החם. התוצאה נשמרת בזיכרון ולא בקובץ. ב-HotSpot: C1 מהדר מהר, C2 מהדר לעומק
Reflectionעבודה עם טיפוסים, שדות ומתודות בזמן ריצהgetDeclared* כולל private בלי ירושה; לגישה לפרטי צריך setAccessible. איטית יותר ושוברת הסתרה
Garbage collectorמשחרר את מה שאי אפשר להגיע אליונגישות משורשים ולא ספירה. System.gc() היא רק בקשה, ודליפה עדיין אפשרית
Mutexמנעול שמחזיק רק thread אחד בכל רגעיש לו בעלים. synchronized ב-Java הוא reentrant, וסדר נעילה קבוע מונע Deadlock

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

צמדהצד הראשוןהצד השני
Overloading מול Overridingהעמסה: נבחרת בהידור לפי הטיפוסים המוצהריםדריסה: נבחרת בריצה לפי האובייקט
virtual מול abstractמגיעה עם מימוש, והיורשת רשאית להחליף אותורק חתימה, ויורשת שאינה אבסטרקטית מוכרחה לכתוב מימוש
override מול new ב-C#דורסת: דרך הפניה לבסיס רצה הגרסה של היורשתמסתירה: דרך הפניה לבסיס רצה הגרסה של הבסיס
Interface מול מחלקה אבסטרקטיתאפשר לממש כמה, ואין בהם מצב של מופעאפשר לרשת רק אחת, ויש בה מצב ובנאים
IComparable מול IComparerההשוואה כתובה בתוך הטיפוס עצמו: סדר טבעי אחדמחלקה נפרדת שמשווה שני אובייקטים: כמה סדרים שרוצים
checked מול uncheckedהמהדר דורש טיפול או הצהרהאין דרישה כזו. ההבדל אינו בחומרה ואינו במי שזורק
finally מול catchרץ תמיד, ולא מטפל בחריגהמטפל, אבל רק בסוג החריגה שלו
Interpreter מול JITמפענח את אותה הוראה שוב בכל פעםמתרגם קוד חם פעם אחת ושומר בזיכרון
JIT מול AOTהידור בריצה, עם מידע על ההתנהגות בפועלהידור מראש, עם הפעלה מהירה
JVM, JRE ו-JDKJVM: המכונה עצמהJRE: המכונה והספריות; JDK: כל זה וגם כלי הפיתוח
getMethods מול getDeclaredMethodsרק ציבוריות, כולל מה שהורשכל מה שנכתב במחלקה, בלי מה שהורש
SoftReference מול WeakReferenceשורדת עד שיש לחץ זיכרוןנעלמת כבר באיסוף הקרוב
Serial מול Parallelעוצר ואוסף ב-thread אחדעוצר ואוסף בכמה threads
Mutex מול Semaphoreאחד בפנים, ויש לו בעליםכמה לפי ההיתרים, ובלי בעלים
Deadlock מול Starvationכולם תקועים במעגל; מונעים בסדר נעילה קבועthread אחד מפסיד שוב ושוב; מונעים במנעול הוגן
מחסנית מול ערמהמשתנים מקומיים וההפניות עצמןהאובייקטים שההפניות מצביעות עליהם
StackOverflowError מול OutOfMemoryErrorהמחסנית העמיקה יותר מדיהערמה התמלאה
טיפ אחרון לפני המבחנים: רוב התשובות השגויות בנויות על משפט שנשמע נכון כמעט לגמרי, עם פרט אחד הפוך. כמו "קוד ה-JIT נשמר בקובץ", "System.gc() מכריחה איסוף" או "כל thread יכול לשחרר Mutex". כשאתם קוראים תשובה, חפשו את הפרט הזה.