מחלקות ב-Java: הגדרת שדות, מתודות ואובייקטים

מחלקה היא תוכנית אב

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

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

class Dog {
    String name;          // שדה: לכל Dog יש שם
    int age;              // שדה נוסף

    void bark() {         // מתודה: התנהגות שיש לכל Dog
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // יצירת אובייקט מתוכנית האב
        d.name = "Rex";       // השמה לשדות שלו
        d.age = 3;
        d.bark();             // קריאה למתודה שלו
    }
}

new Dog() בונה אובייקט בזיכרון ומחזיר לכם הפניה אליו. d.name ו-d.bark() ניגשים לאובייקט הספציפי הזה.

לכל אובייקט יש מצב משלו

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

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex ו-bella הם שני אובייקטים נפרדים. לכל אחד יש name משלו, ולכן כל bark() מדפיס ערך אחר. הנתונים האלה, ששייכים לכל אובייקט בנפרד, נקראים מצב מופע (instance state).

שדות ומתודות עובדים יחד

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

class Counter {
    int count;            // מתחיל ב-0 כברירת מחדל

    void increment() {
        count++;          // מעדכן את השדה של האובייקט הזה
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

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

מילת המפתח this

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

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x הוא השדה; x הוא הפרמטר
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

טעות נפוצה של מתחילים היא לכתוב x = x; בתוך move. זה רק משים את הפרמטר לעצמו ומשאיר את השדה בלי שינוי: הקומפיילר לא יזהיר אתכם, והאובייקט ישמור בשקט את הערכים הישנים. this.x = x; הוא מה שבאמת מעדכן את השדה.

ערכי ברירת מחדל של שדות והפניות null

כשיוצרים אובייקט, השדות שלו לא נשארים עם זבל: Java מאתחלת אותם לערכי ברירת מחדל: 0 למספרים, false ל-boolean, ו-null להפניות לאובייקטים כמו String. ברירת המחדל null הזו היא המקור של קריסה קלאסית.

class User {
    String name;          // לא הושם, ולכן ברירת המחדל היא null
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name הוא null כי אף אחד לא הגדיר אותו, ולכן קריאה ל-.length() עליו זורקת NullPointerException. תמיד השימו ערכים משמעותיים לאובייקט לפני שמשתמשים בשדות שלו, וזו בדיוק הבעיה שבנאים פותרים.

ארגון הקוד סביב מחלקות

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

class BankAccount {
    String owner;
    double balance;

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // אין מספיק כסף
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

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

הבא בתור: בנאים

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