מילות המפתח super ו-this

המילים השמורות this ו-super הן ה"מצפנים" שלנו בתכנות מונחה עצמים. הן עוזרות לנו לנווט בין האובייקט הנוכחי שאנחנו נמצאים בו, לבין החלקים שהוא ירש ממחלקת האב שלו.

1. פנייה לתכונות ומתודות

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

שימוש ב-this (אני)

this.x: ניגש לתכונה של האובייקט הנוכחי. שימושי מאוד כשיש פרמטר בפונקציה עם שם זהה לתכונה (Shadowing).
this.calc(): מפעיל מתודה של המחלקה הנוכחית.

שימוש ב-super (ההורה)

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

2. הפעלת בנאים (Constructors)

כאן הקסם האמיתי קורה. אנחנו יכולים להשתמש ב-this() כדי להפעיל בנאי אחר באותה מחלקה, או ב-super() כדי להפעיל בנאי של מחלקת האב. אבל יש כאן שני חוקי ברזל שחייבים לזכור:

⚠️ חוקי הברזל של שרשור בנאים

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

3. הדוגמה המלאה: שרשור בנאים (Constructor Chaining)

בואו נראה דוגמה מרתקת: ניצור מחלקה של שחקן (Player), ומחלקת בן של קוסם (Wizard). הקוסם מפעיל בנאי של עצמו, שמפעיל בנאי של האב, שמפעיל בנאי אחר של האב!

// === מחלקת האב: Player ===
public class Player {
  protected String name;
  protected int hp;

  // בנאי 1 של האב (המטרה הסופית)
  public Player(String name, int hp) {
    this.name = name; // שימוש ב-this להבדלה מהפרמטר
    this.hp = hp;
    System.out.println("Player created!");
  }

  // בנאי 2 של האב (קורא לבנאי 1)
  public Player(String name) {
    this(name, 100); // שורת חובה ראשונה! מעביר HP דיפולטיבי
  }
}

// === מחלקת הבן: Wizard ===
public class Wizard extends Player {
  private int mana;

  // בנאי 1 של הבן (מפעיל בנאי אחר של הבן)
  public Wizard(String name) {
    this(name, 50); // שלב 1: מפעיל את הבנאי השני של Wizard
  }

  // בנאי 2 של הבן (מפעיל את בנאי האב)
  public Wizard(String name, int mana) {
    super(name); // שלב 2: מפעיל את Player(String), שבתורו מפעיל את Player(String, int)
    this.mana = mana; // רק אחרי שרשרת ההורים הסתיימה, מותר לעשות השמות!
    System.out.println("Wizard ready!");
  }
}

מעקב ריצה: כאשר נכתוב new Wizard("Gandalf"), התוכנית תיכנס לבנאי 1 של הבן → משם תעבור לבנאי 2 של הבן → משם לבנאי 2 של האב → ומשם לבנאי 1 של האב. קודם יוקם האב ("Player created!"), ורק אז יושלם הבן ("Wizard ready!").