טיפוסי נתונים ב-Java: פרימיטיביים, טיפוסי הפניה וערכי ברירת מחדל

שתי משפחות: פרימיטיביים והפניות

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

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

שמונת הטיפוסים הפרימיטיביים

ל-Java יש בדיוק שמונה טיפוסים פרימיטיביים מובנים. שישה הם מספרים, אחד הוא תו ואחד הוא בוליאני:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // מספר שלם של 8 ביט,  -128 .. 127
        short  s = 30000;        // מספר שלם של 16 ביט
        int    i = 2_000_000;    // מספר שלם של 32 ביט (ברירת המחדל למספרים שלמים)
        long   big = 9_000_000_000L; // מספר שלם של 64 ביט: שימו לב ל-L

        float  f = 3.14f;        // מספר עשרוני של 32 ביט: שימו לב ל-f
        double d = 3.141592653589793; // מספר עשרוני של 64 ביט (ברירת המחדל לעשרוניים)

        char   c = 'A';          // תו Unicode יחיד של 16 ביט
        boolean flag = true;     // רק true או false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

כמה דברים ששווה לשים לב אליהם מראש: הקווים התחתונים ב-2_000_000 הם רק מפרידים ויזואליים שהקומפיילר מתעלם מהם, הסיומות L ו-f הן חובה (עוד על זה בהמשך), ו-char משתמש בגרשיים בודדים, ואילו String היה משתמש במירכאות כפולות.

בחירת טיפוס מספרי

כמעט אף פעם לא צריך byte או short: הם חוסכים זיכרון רק במערכים ענקיים. ההחלטות האמיתיות הן בין int/long למספרים שלמים לבין float/double לעשרוניים.

המלכודת היא גלישה (overflow). int מתגלגל בשקט כשהוא חורג מהטווח שלו: בלי שגיאה, רק תשובה שגויה:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // מתגלגל למספר שלילי!

        long safe = (long) maxInt + 1;  // קודם ממירים ל-long
        System.out.println(safe);
    }
}

maxInt + 1 גולש ל--2147483648 כי שני האופרנדים הם int והתוצאה נשארת int. המרה של אחד הצדדים ל-long קודם גורמת לחישוב להתבצע ב-64 ביט. כשערך עשוי להיות גדול, במיוחד מילישניות מאז 1970, בחרו ב-long.

ליטרלים והסיומות שלהם

לליטרל מספרי חשוף יש טיפוס ברירת מחדל, וזה מפיל אנשים. 100 הוא int; 3.14 הוא double. כדי לכתוב ליטרל long או float חייבים להוסיף סיומת:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // בלי L זה גדול מדי ל-int -> שגיאה
        float ratio = 0.5f;               // בלי f הצד של ההשמה הוא double -> שגיאה
        double pi = 3.14;                 // תקין: עשרוניים הם double כברירת מחדל

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

אם תמחקו את ה-L מ-8_000_000_000L הקוד לא יתקמפל, כי הליטרל חורג מהטווח של int עוד לפני שהוא מגיע למשתנה ה-long. אם תמחקו את ה-f מ-0.5f, Java תתלונן שאי אפשר להשים double ל-float בלי המרה. הסיומת לא רגישה לאותיות גדולות וקטנות, אבל השתמשו ב-L גדולה: l קטנה נראית בדיוק כמו הספרה 1.

char הוא מספר בתחפושת

char שומר יחידת קוד Unicode של 16 ביט, כלומר הוא משמש גם כמספר שלם קטן בלי סימן. אפשר לעשות עליו חשבון ולהמיר הלוך ושוב עם cast:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65: ערך ה-Unicode של 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

זה שימושי לפעמים להזזת אותיות, אבל אל תסמכו על זה לטקסט: בשביל זה יש String. שימו לב ש-char משתמש בגרשיים בודדים ('A'); מירכאות כפולות ("A") יוצרות String של תו אחד, שזה טיפוס שונה לגמרי.

ערכי ברירת מחדל (והמלכודת של משתנים מקומיים)

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

public class Main {
    static int counter;        // שדה -> ברירת מחדל 0
    static boolean ready;      // שדה -> ברירת מחדל false
    static String name;        // שדה -> ברירת מחדל null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // איברי המערך מקבלים 0 כברירת מחדל
        System.out.println(nums[0]); // 0
    }
}

אם במקום זה הייתם כותבים int x; System.out.println(x); בתוך main, הקומפיילר היה דוחה את הקוד עם "variable x might not have been initialized". ההקפדה הזו היא יתרון: היא מונעת מכם לקרוא זבל. ערכי ברירת המחדל שכדאי לזכור: טיפוסים מספריים 0, boolean false, char '�', וכל טיפוס הפניה null.

הבא בתור: מחרוזות

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