בנאים ב-Java: אתחול אובייקטים עם new

למה קיימים בנאים

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

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

class Point {
    int x;
    int y;

    Point(int x, int y) {     // בנאי: אותו שם כמו המחלקה, בלי טיפוס החזרה
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // הבנאי רץ כאן
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) מקצה את האובייקט ואז מריץ את גוף הבנאי עם x = 3 ו-y = 4. עד ש-new מחזיר, p מאותחל במלואו.

מילת המפתח this

בבנאי שבדוגמה, לפרמטרים קוראים x ו-y, בדיוק כמו לשדות. this.x אומר "השדה x ששייך לאובייקט הזה", ואילו x לבד מתייחס לפרמטר. בלי this, x = x היה פשוט משים את הפרמטר לעצמו ומשאיר את השדה בלי שינוי.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // שדה = פרמטר
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

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

בנאי ברירת המחדל

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

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

class Box {
    int size;

    Box(int size) {       // עכשיו אין בנאי בלי ארגומנטים
        this.size = size;
    }
}

new Box();   // שגיאת קומפילציה: לא קיים בנאי Box()

אם עדיין רוצים ש-new Box() יעבוד, הצהירו בעצמכם על הבנאי בלי הארגומנטים:

class Box {
    int size;

    Box() {               // בנאי מפורש בלי ארגומנטים
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

העמסת בנאים

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

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // ריבוע 1x1 כברירת מחדל
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // ריבוע
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // מלבן מלא
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java בוחרת את הבנאי המתאים לפי מספר הארגומנטים שמעבירים ל-new והטיפוסים שלהם.

שרשור עם this()

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

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // מעביר את העבודה לבנאי עם שני הארגומנטים
    }

    Rectangle(int side) {
        this(side, side);    // גם הוא מעביר את העבודה
    }

    Rectangle(int width, int height) {   // הבנאי ה"אמיתי" היחיד
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

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

בנאים ו-super()

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

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // כאן חובה לקרוא במפורש לבנאי של מחלקת האב
    }
}

מכיוון שלמחלקה Animal אין בנאי בלי ארגומנטים, Dog חייבת לקרוא ל-super(name) במפורש: אין super() חינמי ליפול אליו. כמו this(), קריאה ל-super(...) חייבת להיות הפקודה הראשונה בבנאי.

הבא בתור: ירושה

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