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 פונה אליה לראשונה, ואת האתחול הזה הוא עצמו מגן.
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.
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 ובדיקה כפולה |
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 trueConsole.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
Trueticks שלמעלה, כל גישה אליו מכמה threads צריכה סנכרון משלה (lock, synchronized או Mutex). הבטיחות של רגע הבנייה לא עוברת למתודות.מה עוקף את המופע היחיד, ומה הדפוס עולה
גם Singleton שכתוב היטב אפשר לעקוף בארבע דרכים, ולכל אחת יש תשובה:
| עקיפה | מה קורה | ההגנה |
|---|---|---|
| Reflection | קוד שקורא ל-setAccessible(true) מסיר את החסימה מהבנאי הפרטי, ואז newInstance בונה דרכו עוד אובייקט | הבנאי זוכר שכבר רץ, ובפעם השנייה זורק חריגה. גרסת enum אינה פגיעה מלכתחילה |
| Serialization | שחזור מקובץ מייצר אובייקט טרי במקום להחזיר את הקיים | readResolve שמחזירה את INSTANCE; enum מקבל את זה בלי קוד |
| Cloning | clone() מעתיק את האובייקט | המחלקה לא מצהירה implements Cloneable |
| כמה ClassLoader | כל ClassLoader מחזיק עותק משלו של המחלקה ושל השדות הסטטיים שלה, כך ששני טוענים נותנים שני מופעים | לזכור שב-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 כדי שה"בנאי" יהפוך למתודה רגילה, כזו שאינה רצה בבנייה:
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
onnew Lamp() הפעיל את בנאי ברירת המחדל שהמהדר הוסיף, ולכן state נשאר off. רק הקריאה המפורשת l.Lamp() שינתה אותו.
ולמה בכלל לאתחל בבנאי? בקוד הבא new Sensor() בלי ערכים לא מחזיר שדות עם תוכן אקראי: Java ממלאת כל שדה שלא קיבל ערך ב-0, ב-false או ב-null. התוצאה צפויה אבל חסרת משמעות, חיישן בלי שם וכבוי, ולכן התפקיד של הבנאי הוא לתת את הערכים שהלוגיקה צריכה.
בנאי עם פרמטרים הוא גם הדרך לייצר הרבה אובייקטים שונים מאותה מחלקה: כל new עם ערכים אחרים מחזיר אובייקט נפרד.
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: המושב שלא נבחר
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(...).
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.
חזרה לתוכן הענייניםבנאים לאורך שרשרת ירושה
בנאים אינם נורשים, ולכן גם אי אפשר לדרוס אותם. מה שכן קורה: כל בנאי של מחלקה יורשת מתחיל בהפעלה של בנאי של מחלקת האב.
| Java | C# | |
|---|---|---|
| הקריאה לבנאי האב | super(...) כפקודה הראשונה בגוף | : base(...) אחרי החתימה |
| אם לא כתבתם כלום | המהדר מוסיף super() ריק | המהדר מוסיף base() ריק |
| קריאה לבנאי אחר באותה מחלקה | this(...) | : this(...) |
| מגדירים שאסור לשים על בנאי | abstract, static, final, synchronized | virtual |
Tablet שבקוד הבא לא כתבה super, ולכן המהדר שתל בשבילה super() ריק. אבל ל-Device יש רק בנאי שמקבל מחרוזת, והקריאה הריקה לא מוצאת התאמה. כשהאב לא מציע בנאי נגיש בלי פרמטרים, היורשת צריכה לקרוא לו בעצמה ולתת לו את הארגומנטים שהוא מבקש:
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: שלושה דורות של מכשירים
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 לא מורשה לגשת אליו. לכן מחלקה שאין לה אלא בנאים פרטיים חסומה לירושה מבחוץ, והכישלון מתגלה כבר בקומפילציה, לא בזמן ריצה:
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# בונות אובייקט של יורשת בסדר שונה, וההבדל קובע מה מתודה רואה באמצע הבנייה.
| שלב | Java | C# |
|---|---|---|
| ראשון | בנאי האב, כולל אתחולי השדות של האב | אתחולי השדות של היורשת |
| שני | אתחולי השדות של היורשת, כמו String label = "OK", לפי סדר הכתיבה | אתחולי השדות של האב, ואחריהם גוף הבנאי של האב |
| שלישי | שאר גוף הבנאי של היורשת | גוף הבנאי של היורשת |
ועכשיו המקרה המסוכן: בנאי האב קורא למתודה שהיורשת דורסת. בשתי השפות הקריאה מגיעה לגרסה של היורשת, עוד לפני שגוף הבנאי של היורשת התחיל לרוץ.
תרחיש 5: כפתור שעוד לא קיבל תווית
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=truenew Button() מתחיל בבנאי של Widget, דרך ה-super() שהמהדר הוסיף, והבנאי הזה קורא ל-render().
האובייקט שבבנייה הוא Button, ולכן רצה הגרסה הנדרסת של Button. אבל האתחולים label = "OK" ו-enabled = true עוד לא בוצעו, כי ב-Java הם רצים רק אחרי שבנאי האב חוזר, והמתודה רואה null ו-false.
בנאי האב מסתיים, השדות מקבלים את הערכים שלהם, והגוף של Button כבר מדפיס OK ו-true.
אותו מבנה ב-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++ שונה משתיהן: בזמן שבנאי של מחלקה רץ, קריאה וירטואלית מתוכו מגיעה לגרסה של המחלקה שהבנאי שלה פועל כרגע, לא לגרסה של היורשת.
#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.
טעויות נפוצות
- המהדר מוסיף בנאי ריק לכל מחלקה. רק למחלקה שאין בה אף בנאי כתוב. בנאי אחד שלכם מבטל את המתנה.
- אם היורשת לא כותבת
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), ומכל מחלקה יורשת, גם כשהיא בחבילה אחרת.
כלומר ההרשאה רחבה יותר מ"יורשות בלבד": החבילה כולה בפנים.
| מהצר לרחב | מילת מפתח | מי ניגש |
|---|---|---|
| 1 | private | המחלקה עצמה |
| 2 | בלי מילה (package-private) | כל המחלקות בחבילה |
| 3 | protected | כל החבילה, ובנוסף יורשות מכל חבילה |
| 4 | public | כולם |
שימו לב ש-package-private בטבלה הוא שם תיאורי, לא מילת מפתח: לרמת החבילה Java לא הקצתה מילה בכלל, ומשאירים את האיבר בלי מגדיר, כך שמגדיר בשם package לא קיים. גם internal ו-friend לא מופיעים בטבלה, כי internal לקוחה מ-C# ו-friend מ-C++, ולכן בשאלה על Java שתיהן תשובות שגויות.
שני כללי משנה חלים על יורשת שנמצאת בחבילה אחרת. את האיבר המוגן שירשה היא מקבלת רק דרך הפניה מהטיפוס שלה, כמו this.balance, ולא דרך הפניה מטיפוס האב. ובנאי protected של האב זמין לה רק דרך super(...), לא דרך new.
// 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 errorsAudit אינה יורשת, אבל היא באותה חבילה, ולכן הגישה שלה עברה בלי הערה. ב-Savings עברו הגישה דרך this וה-super() המשתמע אל הבנאי המוגן. נכשלו רק הגישה דרך הפניה מטיפוס Account וה-new הישיר.
ועוד שני כללים: בדריסה מותר להרחיב הרשאה, למשל מ-protected ל-public, אבל אסור לצמצם אותה. ומחלקה ברמה העליונה של קובץ לא יכולה להיות protected, בעוד שמחלקה מקוננת יכולה.
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 errorprotected class Top { }Top.java:1: error: modifier protected not allowed here
protected class Top { }
^
1 errorprotected ב-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, מקבל את ערכיו מהבנאי המוגן. לכן הטענה שהבנאי לא נקרא "כי אין מופעים של מחלקה אבסטרקטית" שגויה.
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 במחלקה היורשת. מבחוץ, לעומת זאת, שתי הגישות נחסמות:
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 levelCS0144 מונע בנייה ישירה של המחלקה האבסטרקטית. 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.
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, לא פוטרים מכלום.
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 בזמן ריצה.
| תוספת | גרסה | מה היא מאפשרת |
|---|---|---|
מתודת default | Java 8 | גוף בתוך הממשק. כך מוסיפים מתודה לממשק קיים בלי לשבור את המחלקות שכבר מממשות אותו, ומי שרוצה התנהגות אחרת דורסת |
מתודת static | Java 8 | גוף עם המילה static. היא לא נורשת, וקוראים לה רק דרך שם הממשק, לא דרך המחלקה המממשת ולא דרך מופע |
מתודת private | Java 9 | קוד עזר פנימי שמתודות הממשק משתפות |
| חבר ממשק עם מימוש (default interface member) | C# 8 | גוף בתוך הממשק, שנגיש רק דרך הפניה מטיפוס הממשק |
תרחיש 6: תרמוסטט עם קבוע, default ו-static
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
30Hall מימשה מתודה אחת בלבד, read(). ובכל זאת t.report() עובדת: זו מתודת default שכתובה בממשק, והיא קוראת ל-read() של Hall.
את toF הפעלנו דרך Thermostat, השם של הממשק: 21 מעלות צלזיוס הן 69 פרנהייט בחשבון של שלמים. גם MAX_C נקרא דרך שם הממשק, כמו כל קבוע סטטי.
וכך נראה ניסיון להשתמש בשניהם בדרך הלא נכונה:
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# מתודה שכתוב לה גוף בממשק לא נוספת למחלקה עצמה. דרך הפניה מטיפוס הממשק היא זמינה:
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אבל קריאה ישירה דרך ביטוי מטיפוס המחלקה לא מתקמפלת:
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) במקום האמיתי.
הממשק לא כותב את הבדיקות, וגם לא פותח להן את השדות הפרטיים. הוא רק מאפשר את ההחלפה.
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 passedConverter לא יודע ש-fake אינו מקור שערים אמיתי. הבדיקה רצה בלי רשת, ותוצאתה ידועה מראש: 25 כפול 4.
ירושה מרובה: Java לא מרשה לרשת משתי מחלקות, גם אם שתיהן אבסטרקטיות. כדי לשלב יכולות מממשים כמה ממשקים ומוסיפים הרכבה (Composition): המחלקה מחזיקה אובייקטים שכבר יודעים לבצע כל יכולת, ומעבירה אליהם את העבודה.
Warehouse שבקוד הבא מגדירה בתוכה ממשק קטן, Rule, שמתאר בדיקה של משקל. זה ממשק מקונן (nested interface): הוא נותן לחלקים של מחלקה גדולה חוזה משותף לעבוד לפיו, ומכיוון שהוא private, קוד מחוץ ל-Warehouse לא יודע שהוא קיים.
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
falseDrone עומדת בשני חוזים, ואת העבודה עצמה עושים 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).
ומה כן משתנה? העסקה שנבנתה כאשראי תישאר אשראי עד סוף חייה. מה שמתחלף מאיטרציה לאיטרציה הוא האובייקט שההפניה מצביעה עליו.
מה המהדר רואה ומה רץ בפועל
שני כללים פועלים במקביל, כל אחד בשלב אחר:
- בקומפילציה המהדר מסתכל רק על הטיפוס המוצהר של המשתנה, ומתיר לקרוא רק למתודות שקיימות בו.
- בזמן ריצה, אם המתודה נדרסה, מתבצעת הגרסה של הטיפוס שבפועל.
המרה כלפי מעלה, מ-Guitar ל-Instrument, קורית מעצמה. המרה כלפי מטה דורשת סוגריים מפורשים, והיא נבדקת בזמן ריצה: אם האובייקט אינו מהטיפוס המבוקש, ב-Java נזרקת ClassCastException, וב-C# נזרקת InvalidCastException.
תרחיש 7: להקה שמנגנת דרך טיפוס אחד
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() ישירות דרך משתנה מטיפוס הבסיס? אז הקוד לא מגיע לזמן ריצה בכלל:
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 אינן ניתנות לדריסה.
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: חשבונית שהוצהרה כמסמך
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 #88d מוצהר כ-Document. כשהמהדר בוחר בין שתי הגרסאות של send, הוא מסתכל על הטיפוס המוצהר בלבד, ולכן נבחרת send(Document), אף שבזמן ריצה יש שם חשבונית.
בתוך send(Document) הקריאה d.title() היא דריסה, ולכן היא מגיעה דווקא לגרסה של Invoice: invoice #88.
בקריאה השנייה ההמרה משנה את הטיפוס המוצהר של הביטוי ל-Invoice, והמהדר בוחר בגרסה הספציפית.
שורה אחת מדגימה את שני הכללים: את ההעמסה הכריע הטיפוס המוצהר, ואת הדריסה הכריע האובייקט.
שדות ומתודות static לא משתתפים בפולימורפיזם. גם כשהיורשת מגדירה שדה או מתודה סטטית באותו שם, הבחירה נעשית לפי הטיפוס המוצהר:
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.
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.0MinusTen נוספה אחרונה, ו-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.
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#:
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 errorclass 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שלוש שפות, שלוש ברירות מחדל
| Java | C# | C++ | |
|---|---|---|---|
| ברירת המחדל | וירטואלית, חוץ ממתודות static, private ו-final | לא וירטואלית | לא וירטואלית |
| מה כותבים בבסיס | שום דבר: אין ב-Java מילה virtual | virtual או abstract | virtual |
| מה כותבים ביורשת | דריסה רגילה (מומלץ @Override) | override חובה; new מסתיר במקום לדרוס | אותה חתימה |
| קריאה לגרסת האב | super.m() | base.M() | Base::m() |
ב-C# הצירוף מחייב: אם בבסיס המתודה אינה virtual, abstract או override, אסור לכתוב override ביורשת:
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 של היורשת ירוץ:
#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
~Shapename() אינה וירטואלית, ולכן רצה גרסת Shape, לפי סוג המצביע. draw() וירטואלית, ולכן רצה גרסת Hexagon. וה-destructor הווירטואלי דאג ששני ה-destructors ירוצו, מהיורשת אל הבסיס.
תרחיש 9: override מול new ב-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 footerHeader מסומנת 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 גולש ומחליף סימן:
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: חדרים לפי קומה ואחר כך לפי מספר
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
InvalidOperationExceptionrooms.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 ומחלקה בלי סדר
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. ב-JavacompareTo(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: ארנק, שער ותזכורת: שלושה פרמטרים, שלוש תוצאות
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 2rateהוא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
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
8Coordהואstruct, ולכןShiftשינתה העתק שלם ו-c.Rowנשאר 8.Markerהיאclass, ולכןShiftכתבה לאותו אובייקט ו-m.Rowהפך ל-50.- עם
ref, ההחלפה ב-Swapנעשתה במשתנים שלMainעצמם, משהו שב-Java אי אפשר לכתוב. hהוצהר בלי ערך, ו-TryHalfהציבה בו 7 דרךout.Peekקיבלה אתcדרךin: הפניה בלי העתקה, אבל בלי רשות לכתוב.
המהדר אוכף את שני כללי האתחול. משתנה לא מאותחל שנשלח ב-ref, ומתודה ששוכחת להציב ערך בפרמטר out, נכשלים שניהם בהידור:
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): המקרה שבו הפונקציה חוזרת בלי לקרוא לעצמה. זה החלק הקריטי ביותר בהגדרה, כי בלעדיו הקריאות לא נגמרות.
- צעד רקורסיבי: הקריאה העצמית, עם קלט שמתקדם לעבר תנאי העצירה.
היא מתאימה במיוחד למבנים היררכיים, כמו עץ תיקיות, עץ חיפוש או רשימה שמכילה רשימות. הפונקציה מטפלת בצומת אחד ושולחת את עצמה לכל תת-מבנה, ולכן הקוד קצר ונראה כמו ההגדרה של המבנה עצמו:
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));
}
}19countFiles סופרת את הקבצים של התיקייה שלפניה ומוסיפה את מה שמחזירה כל תת-תיקייה: 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: הדפסה משני צידי הקריאה
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 out3echo(3)מדפיסהin3וקוראת ל-echo(2), שמדפיסהin2וקוראת ל-echo(1), שמדפיסהin1.echo(0)פוגעת בתנאי העצירה וחוזרת מיד, בלי להדפיס.- השליטה חוזרת ל-
echo(1), שממשיכה מהשורה שאחרי הקריאה ומדפיסהout1. אחריהecho(2)מדפיסהout2, ובסוףecho(3)מדפיסהout3. - כל קריאה הדפיסה את ה-
nשלה בשני המקומות, כי ה-nשלה לא השתנה בזמן שהקריאות הפנימיות רצו.
מסגרות על המחסנית, ומה קורה כשהיא מתמלאת
על כל קריאה ה-thread מוסיף למחסנית הקריאות שלו מסגרת חדשה (stack frame). במסגרת נשמרים הפרמטרים והמשתנים המקומיים של אותה קריאה, והיא משתחררת רק כשהקריאה חוזרת.
בתרחיש שבהמשך, digits(40917) מחזיקה בשיא חמש מסגרות פתוחות בבת אחת, ואילו לולאה שעושה את אותה עבודה הייתה מסתפקת בשני משתנים שמתעדכנים. זה כל ההסבר לזיכרון הנוסף: הקוד המהודר של digits קיים פעם אחת בלבד, ואף new לא מתבצע בגלל הקריאות.
כשתנאי העצירה לא מושג לעולם, או כשהעומק עצום (נניח מיליון קריאות מקוננות), המחסנית מתמלאת. מה שקורה אז תלוי בפלטפורמה:
- ב-Java נזרקת
StackOverflowError. היאErrorולאException, ולכן unchecked: המהדר לא דורש לתפוס אותה או להכריז עליה ב-throws(הכרזה כזו מותרת, פשוט מיותרת). - ב-.NET נזרקת
StackOverflowException. אי אפשר לתפוס אותה, והתהליך כולו מסתיים.
אל תצפו להצלה אוטומטית. את גודל המחסנית של thread קובעים לפני ההרצה, באפשרות -Xss, והוא לא מתרחב באמצע; ומה ה-GC וה-JIT לא יעשו כאן, תמצאו בטעויות הנפוצות בסוף הנושא.
תרחיש 15: ספירת מסגרות, ותנאי עצירה שלא מושג
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: falsedigits(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.
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 כברירת מחדל, אף שהקריאה שלה בזנב:
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 ספציפי הופך את הספציפי לבלתי ניתן להגעה, והמהדר מסרב:
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.
כדי לראות מה המנגנון שווה, השוו שתי דרכים לדווח על גיל לא תקין: ערך מיוחד שמוחזר, או חריגה.
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.
| סוג | מי שייך אליו | מה המהדר דורש |
|---|---|---|
| unchecked | RuntimeException וכל צאצאיה: 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 בשקט.
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: הכרזה בלי טיפול
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
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: שלושה משאבים וחריגה באמצע
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: סריקת עץ שנעצרת בפריט פגום
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, היה רק מריץ ניקוי בדרך, בלי לשנות לאן החריגה מגיעה. - המשתמש קיבל הודעה אחת. אילו כל רמה הייתה תופסת ומחזירה ערך ברירת מחדל, הסריקה הייתה ממשיכה והתקלה הייתה נעלמת.
חריגה שמשמשת כתשובה רגילה, ולא כסימן לתקלה, עולה ביוקר. שתי הגרסאות של הבדיקה שלהלן נותנות אותה תשובה, אבל בדרכים שונות מאוד:
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 לא יוצרת שום אובייקט.
ומה בדיוק נבנה? גם בלי לזרוק:
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
makeCost מראה מה נכלל בבנייה של חריגה. כבר ב-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 מציג את הפקודות:
public class Fees {
static int total(int price, int qty) {
return price * qty + 5;
}
}
class Receipt { }javac Fees.java # one source file, two classes
ls *.class
javap -c FeesFees.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:
print(open('Fees.class', 'rb').read(8).hex()) # magic, minor version, major versioncafebabe00000034ארבעת הבתים האחרונים הם הגרסה: 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.
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 רץ
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: 0Bootהיא המחלקה הראשית, ולכןinit Bootמודפס עוד לפני השורה הראשונה שלmain.Settings.MAX_USERSהודפס בלי ש-Settingsאותחלה: 3 הועתק לקוד שלBootבזמן הידור.Settings.hitsאינוfinal, ולכן הקריאה שלו היא שימוש פעיל: הבלוק הסטטי רץ ממש לפניה.- בקריאה השנייה של
hitsהבלוק לא רץ שוב. Class.forName("Plugin")טענה ואתחלה אתPluginמיד, אף שלא נוצר ממנה אובייקט.
כשהשימוש הפעיל הראשון הוא new, הסדר קבוע: קודם המחלקה מאותחלת והבלוק הסטטי רץ, ורק אחר כך גוף הבנאי. כל new נוסף כבר מוצא מחלקה מאותחלת, ולכן מריץ רק את הבנאי:
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 יש שתי מחלקות, ולכל אחת מהן שדות סטטיים משלה:
// plugins/Meter.java, compiled into the plugins folder (javac -d plugins plugins/Meter.java)
public class Meter {
public static int reads = 0;
}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
nullLoaders רצה מהתיקייה שמכילה את 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).
סדר האירועים בהפעלה:
- ה-JVM עולה.
- היא טוענת את המחלקה הראשית ומאתחלת אותה, כך שהבלוקים ה-
staticשלה רצים לפניmain. - היא מריצה את
mainב-thread ששמוmain. - שאר המחלקות נטענות ומאותחלות בהמשך, כל אחת בשימוש הראשון בה.
בתרחיש שלהלן, java Greet ruth 42 ממלא את args בשני איברים בלבד, אלה שבאים אחרי שם המחלקה. לא java ולא Greet נכנסים למערך, ובזה Java שונה מ-C, שבה argv[0] הוא שם התוכנית. וכשלא נותנים אף ארגומנט, מקבלים מערך באורך 0 ולא null.
תרחיש 21: מה מגיע ל-args
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? falseGreetהוא שם המחלקה ולא נכנס למערך.ruthהואargs[0]ו-42הואargs[1], כמחרוזת.- בהרצה בלי ארגומנטים הלולאה לא רצה אף פעם, ו-
argsעדיין אובייקט קיים.
main בלי static מתקמפלת בלי שום שגיאה, אבל עד Java 24 ה-launcher מסרב להריץ אותה. הפלט כאן מ-Java 8; מ-Java 25 מותרת גם main של מופע, וה-launcher יוצר את האובייקט בעצמו.
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 מציג אותו:
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 הן גוף הלולאה. עבור רשימה של מיליון קופסאות המפרש יקרא, יפענח ויבצע את אותן ארבע הוראות מיליון פעמים. זו כל הסיבה ללולאה איטית במפרש.
עוד תכונה שנובעת מהביצוע תוך כדי: מפרש לא בודק את כל התוכנית לפני שהיא מתחילה. בשפה דינמית כמו Python, שגיאה בשורה מסוימת מתגלה רק ברגע שהביצוע מגיע אליה. בדוגמה הבאה הקובץ הוזן למפרש דרך הקלט הסטנדרטי (python - < late.py):
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, בחלק הבא. באותו אופן הוא גם לא מתכונן מראש: מחלקות וספריות נטענות כשהביצוע מגיע אליהן, ולא כולן לפני השורה הראשונה.
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:
java -XX:+PrintFlagsFinal -version | grep TieredCompilation bool TieredCompilation = true {pd product}| מהדר | מהירות ההידור | עומק האופטימיזציה | תפקיד נוסף |
|---|---|---|---|
| C1 | מהיר | קל | אוסף פרופיל: אילו ענפים נלקחים, אילו טיפוסים מגיעים לכל קריאה |
| C2 | איטי יותר | כבד ואגרסיבי | מהדר מחדש רק את הקוד החם ביותר, בעזרת הפרופיל ש-C1 אסף |
שימו לב ששניהם מהדרים. אף אחד מהם אינו מפרש, ואף אחד מהם אינו פועל לפני שהתוכנית מתחילה לרוץ: הפרשנות היא תפקיד של המפרש, ושני המהדרים נכנסים לפעולה רק בזמן הריצה.
היתרון של JIT על מהדר מראש הוא המידע: הוא רואה איך התוכנית מתנהגת באמת. בעזרת המידע הזה הוא מבצע inline (מעתיק את גוף המתודה הנקראת אל מקום הקריאה וחוסך את הקריאה עצמה), escape analysis (מזהה אובייקטים שלא יוצאים מהמתודה), אופטימיזציות של לולאות, והסרה של קוד מת שאף פעם לא רץ.
המקרה המעניין ביותר הוא devirtualization. קריאה וירטואלית בדרך כלל עוברת דרך טבלת המתודות של האובייקט כדי למצוא את הגרסה הנכונה. אבל אם הפרופיל מראה שבנקודת קריאה מסוימת מגיע תמיד אובייקט מאותו סוג, ה-JIT מניח שכך יימשך ומשבץ שם ישירות את הגוף של הגרסה של אותו סוג.
הרווח כפול: אין עוד חיפוש בטבלת המתודות, וגוף המתודה נעשה גלוי למהדר בתוך הקוד שקרא לו, ולכן אפשר להפעיל עליו אופטימיזציות נוספות יחד עם הסביבה שלו.
ומה אם ההנחה מתבררת כשגויה? ה-JVM עוקבת אחרי טעינת מחלקות, ולכן ברגע שנטענת מחלקה יורשת שעלולה להגיע לאותה קריאה, הקוד המהודר שנשען על ההנחה מבוטל, והמתודה חוזרת זמנית למפרש. לזה קוראים deoptimization, ובזכותו התוכנית ממשיכה להתנהג בדיוק כמו קודם.
תרחיש 22: מתודה שמתחממת, מתקררת ומתחממת שוב
שירות משלוחים ב-Java מחשב לכל הזמנה את המחיר במתודה quote, ובתוכה יש קריאה וירטואלית carrier.cost(weight).
- ההזמנות הראשונות:
quoteרצה במפרש, וה-JVM סופרת כל קריאה. - המונה עובר את הסף: C1 מהדר את
quoteבמהירות. השירות כבר מהיר יותר, ו-C1 רושם פרופיל. - הפרופיל מגלה שכל הקריאות ל-
carrier.costהגיעו עד כה למחלקהTruckCarrier. quoteנעשית אחת המתודות החמות ביותר, ו-C2 מהדר אותה מחדש. הפעם גוףTruckCarrier.costמשובץ בתוכה, ואין חיפוש בטבלת המתודות.- בשלב מאוחר נטענת מחלקה חדשה
DroneCarrier, והזמנה ראשונה עם רחפן מגיעה ל-quote. ההנחה נשברה: הקוד של C2 מבוטל,quoteחוזרת למפרש, ואחרי שתצבור פרופיל חדש תהודר שוב. - בלילה השירות מופעל מחדש. אין שום קוד מכונה בקובצי ה-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:
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עקבו אחרי הפלט לפי הסדר:
- השדה
targetנמצא עםgetDeclaredField, אבל ה-getהראשון נחסם, כי עוד לא נקראsetAccessible. - אחרי
setAccessible(true)על ה-Field, אותו אובייקט שינה את הערך ל-24 וקרא אותו בחזרה. - המתודה הפרטית
calibrateהופעלה לפי השם וטיפוס הפרמטר שלה, אחריsetAccessibleמשלה. getFieldלא מצא אתtarget, כי הוא מסתכל רק על שדות public.- שגיאת כתיב בשם (
calibrat) התגלתה רק בריצה, כ-NoSuchMethodException. 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, יוצרת מופע, ומשם עובדת איתו דרך ממשק שהיא מכירה:
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 מחזירה אותנו לקוד רגיל שהמהדר בודק.
Exporter ex = new CsvExporter();, קריאה ישירה ומהירה שהמהדר בודק. Reflection שמורה למחלקות שהזהות שלהן נודעת רק בזמן ריצה.וכדי לא להגזים ביכולות של מסגרת בדיקות: היא לא מריצה כל בדיקה בתהליך נפרד בזכות Reflection, היא לא ממציאה בדיקות בעצמה, והיא לא מריצה קוד מקור שלא הודר. היא רק מוצאת ומפעילה.
חזרה לתוכן הענייניםהמחיר: מהירות, הסתרה ושמות כמחרוזות
מהירות. קריאה דרך invoke בדרך כלל איטית מקריאה ישירה, מארבע סיבות: המתודה מאותרת לפי שם, הרשאות הגישה נבדקות בכל קריאה, ארגומנטים פרימיטיביים נארזים לאובייקטים (boxing), וה-JIT מצליח לבצע פחות אופטימיזציות.
הסיבות הבאות אינן חלק מהמחיר: אין טעינה מחדש של קובץ ה-class מהדיסק, אין תרגום מקוד המקור, ואין שכפול של האובייקט. חיסכון ראשון: לשמור את אובייקט ה-Method במשתנה ולא לחפש אותו בכל פעם.
חלופה מהירה יותר קיימת מ-Java 7: MethodHandle מהחבילה java.lang.invoke. זו הפניה מוקלדת (typed) למתודה. בדיקת ההרשאות נעשית פעם אחת, כשיוצרים אותה דרך Lookup, וה-JIT מסוגל לשבץ אותה (inline) במקום הקריאה, כך שהקריאה מהירה יותר:
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 |
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 של התוכנית שקורא מהתור יודע שהגיע הזמן לנקות, לפני שהזיכרון משתחרר סופית. אין הבטחה שהניקוי ירוץ מיד.
Cleaner, והיא הדרך המומלצת היום לניקוי כזה, במקום finalize().דליפות זיכרון, משאבים ו-finalizer
GC לא מבטל דליפות זיכרון; הוא משנה את ההגדרה שלהן. דליפה בשפה עם GC היא אובייקטים שהתוכנית כבר לא צריכה, אבל עדיין אפשר להגיע אליהם. מבחינת ה-GC הם חיים, ולכן הוא לא יכול לגעת בהם.
המקורות הנפוצים: אוסף סטטי (רשימה, מפה, Cache) שרק מוסיפים אליו, ומאזינים או event handlers שנרשמו ולא הוסרו. ה-GC אכן מצמצם דליפות, כי כל מה שבלתי נגיש משתחרר בלי התערבות; הוא פשוט לא יכול לעזור כשהתוכנית ממשיכה להחזיק הפניה.
תרחיש 25: יומן ביקורת שאוכל את הערמה
שירות שומר צילום מצב לכל פעולה במפה סטטית. הוא הורץ כאן עם java -Xmx32m AuditTrail, ערמה קטנה בכוונה כדי להגיע לסוף מהר:
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 מחליט עליו: לא ברגע שנעלמת ההפניה האחרונה ולא ביציאה מהבלוק, ולכן הוא לא מתאים לסגירה של קובץ בזמן.
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:
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 שכבר מחזיק בו יכול לבקש אותו שוב ולהיכנס מיד. לכן כשמתודה מסונכרנת של אובייקט קוראת למתודה מסונכרנת נוספת שלו, שום דבר לא נתקע:
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 deadlockwithdrawAll כבר מחזיקה את המנעול של האובייקט, ו-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 מנסים את מזלם:
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? falsequickמשתמש ב-tryLock()ומקבל false מיד, ואז מחכה 100 מילישניות עםtryLockעם זמן, ושוב מקבל false. הוא אף פעם לא נתקע.patientנחסם בתוךlockInterruptibly(). כש-mainקורא ל-interrupt()עליו, ההמתנה נקטעת והוא נכנס ל-catch שלInterruptedException, בלי לקבל את המנעול.- המנעול זוכר ש-
mainהוא הבעלים שלו. לכן כש-intruderקורא ל-unlock(), הבקשה נדחית מיד עםIllegalMonitorStateException. - רק הבעלים,
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 שכבר מחזיק בו יכול להיכנס אליו שוב.
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(), וגם כאן לשחרור יש בעלים:
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 אחד נועל את המלאי ואז את הספר החשבונאי, והשני נועל באותו זמן את הספר ואז את המלאי:
// 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 או יותר מחכים זה לזה במעגל | כן, לתמיד |
| Livelock | threads משחררים ותופסים שוב בתגובה זה לזה, ושום דבר לא מתקדם | לא, הם עסוקים כל הזמן |
| Priority Inversion | thread בעדיפות נמוכה מחזיק מנעול ש-thread בעדיפות גבוהה צריך | הגבוה מחכה לנמוך |
| Race Condition | תוצאה שתלויה בשילוב המקרי של ה-threads בגישה לנתונים | לא; כאן הבעיה היא דווקא חוסר במנעול |
| Starvation | thread מסוים מפסיד שוב ושוב, ואחרים תמיד מקבלים את המנעול לפניו | רק הוא, והוא עדיין עשוי להתקדם מתישהו |
לסדר נעילה לא מתואם התוצאה הקלאסית היא Deadlock, לא Livelock ולא תנאי מירוץ. ומנעול הוא התרופה לתנאי מירוץ, לא הגורם שלו.
נגד Starvation (הרעבה) משתמשים במנעול הוגן (Fair Lock), למשל ReentrantLock שנבנה עם fairness=true, שנותן את המנעול לפי סדר ההמתנה בתור. להגדיל את מספר הניסיונות האקראיים לא מבטיח כלום, ו-synchronized לא יעזור כאן, כי הוא לא מבטיח לממתינים שום סדר.
Semaphore נראה דומה ל-Mutex, אבל הוא סופר היתרים (permits) במקום להחזיק בעלים אחד. כל רכישה מורידה היתר, כל שחרור מוסיף, ו-thread שמבקש כשאין היתרים נחסם. וכל thread רשאי לשחרר, גם אם לא רכש:
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| Mutex | Semaphore | |
|---|---|---|
| כמה בפנים בבת אחת | 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 ו-JDK | JVM: המכונה עצמה | JRE: המכונה והספריות; JDK: כל זה וגם כלי הפיתוח |
| getMethods מול getDeclaredMethods | רק ציבוריות, כולל מה שהורש | כל מה שנכתב במחלקה, בלי מה שהורש |
| SoftReference מול WeakReference | שורדת עד שיש לחץ זיכרון | נעלמת כבר באיסוף הקרוב |
| Serial מול Parallel | עוצר ואוסף ב-thread אחד | עוצר ואוסף בכמה threads |
| Mutex מול Semaphore | אחד בפנים, ויש לו בעלים | כמה לפי ההיתרים, ובלי בעלים |
| Deadlock מול Starvation | כולם תקועים במעגל; מונעים בסדר נעילה קבוע | thread אחד מפסיד שוב ושוב; מונעים במנעול הוגן |
| מחסנית מול ערמה | משתנים מקומיים וההפניות עצמן | האובייקטים שההפניות מצביעות עליהם |
| StackOverflowError מול OutOfMemoryError | המחסנית העמיקה יותר מדי | הערמה התמלאה |