משתנים ב-Java: הצהרה, השמה ו-Scope

מה זה משתנה

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

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

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

קראו את int age = 30; כ"צור int בשם age ושים בו 30". הנקודה-פסיק מסיימת את ההוראה, בדיוק כמו שעמוד ההערות הראה שכל הוראה מסתיימת.

להצהיר עכשיו, להשים אחר כך

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

public class Main {
    public static void main(String[] args) {
        int score;        // הוצהר, עדיין בלי ערך
        score = 95;       // הושם עכשיו
        score = 100;      // הושם מחדש - תקין לגמרי

        System.out.println(score);
    }
}

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

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

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

כללי שמות ומוסכמות

Java אוכפת כמה כללים נוקשים, ומעליהם יש מוסכמות. הכללים: שם יכול להכיל אותיות, ספרות, _ ו-$, אבל לא יכול להתחיל בספרה, לא יכול להיות מילה שמורה (כמו int או class), והוא רגיש לאותיות גדולות וקטנות (age ו-Age הם שני משתנים שונים).

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

• משתנים ומתודות נכתבים ב-camelCase: firstName, totalScore.
• קבועים נכתבים ב-UPPER_SNAKE_CASE: MAX_USERS.
• שמות צריכים לתאר את הערך: count ולא c; userEmail ולא x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

שמות ברורים הם לא קישוט: הם הדרך שבה אתם בעתיד תקראו את הקוד. totalPrice = itemCount * pricePerItem מסביר את עצמו באופן ש-t = c * p לעולם לא יצליח.

בטיחות טיפוסים: הקופסה שומרת על הטיפוס שלה

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

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

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

מילת המפתח var

מאז Java 10 אפשר לכתוב var במקום הטיפוס ולתת למהדר להסיק אותו מהערך שמימין:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // מוסק כ-String
        var count = 5;                 // מוסק כ-int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var היא לא טיפוסיות דינמית: name הוא String בדיוק כמו אילו כתבתם String name, ועדיין אי אפשר להשים בו int מאוחר יותר. היא רק חוסכת הקלדה. הקאץ': var צריכה ערך התחלתי כדי להסיק ממנו, ולכן var x; אינו חוקי, והיא עובדת רק עבור משתנים מקומיים, אף פעם לא עבור שדות, פרמטרים של מתודות או טיפוסי החזרה. השתמשו בה כשהטיפוס ברור מהצד הימני; כתבו את הטיפוס במפורש כשזה מוסיף בהירות.

קבועים עם final

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

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // לא יתקמפל - אי אפשר להשים מחדש משתנה final
    }
}

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

ה-scope של משתנים

משתנה קיים רק בתוך הבלוק, ה-{ ... }, שבו הוצהר, והוא מת בסוגר המסולסל הסוגר. זה ה-scope (טווח ההכרה) שלו. משתנה שהוצהר בתוך לולאת for או בלוק if אינו נראה מחוץ לו:

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' חי רק בתוך גוף הלולאה הזו
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // שגיאה - 'square' מחוץ ל-scope כאן
    }
}

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

הבא בתור: טיפוסי נתונים

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