הבנת סוגי נתונים ב-Java

הסופר בחר ב־קרן הקוד הפתוח והחינמית לקבל תרומה כחלק מתוכנית כתיבה בתמורה לתרומות.

הקדמה

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

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

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

דרישות מוקדמות

כדי לעקוב אחרי המדריך הזה, תצטרכו:

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

  • Java (גרסה 11 ומעלה) מותקנת על המחשב שלך, עם המהדר הניתן על ידי ערכת הפיתוח ל-Java (JDK). עבור Ubuntu ו-Debian, עקוב אחר השלבים ב- אפשרות 1 במדריך שלנו, איך להתקין את Java עם Apt על Ubuntu 22.04. עבור מערכות ההפעלה האחרות, כולל Mac ו-Windows, ראה אפשרויות ההורדה להתקנת Java.
  • כדי להדפיס ולהריץ את דוגמאות הקוד, המדריך משתמש ב- Java Shell, שהוא סביבת עבודה תומכת (REPL) המופעלת משורת הפקודה. כדי להתחיל עם JShell, ראה את מדריך המבוא ל-JShell.

• ידיעה בג'אווה ותכנות מונחה עצמים, אשר תוכל למצוא במדריך שלנו, איך לכתוב את התוכנית הראשונה שלך ב־Java.

סוגי בסיס

סוגי הנתונים הפרימיטיביים ב-Java הם הסוגים הפשוטים והבסיסיים ביותר ב-Java. הם מייצגים ערכים גולמיים כמו מספרים ותווים. סוגי הנתונים הפרימיטיביים הכי נפוצים הם int (מספרים שלמים), boolean (ערכי בוליאני), ו-char (תווים). באפשרותך למצוא את שארם בתיעוד הרשמי של סוגי הנתונים ב-Java.

מספרים שלמים

מספרים שלמים הם גם מספרים שליליים וחיוביים שלמים. ב-Java, תשתמש ב-int כדי לאחסן אותם. int יכול להכיל מספרים מספיק גדולים לרוב המטרות: מ--2,147,483,648 עד 2,147,483,647.

בוא נסתכל על כיצד int משמש בדוגמה:

int theAnswer = 42;

סוגי הנתונים הפרימיטיביים מתחילים תמיד באות קטנה (int). חוקי התחביר של Java מחייבים שתתחילו ראשית בציון של סוג הנתונים (int) ואז בשמו (theAnswer). לאחר מכן, תקצו את הערך 42 באמצעות סימן השיוויון (=) למשתנה.

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

לאחר שהגדרת את המשתנה, תוכל להשתמש בו על ידי התייחסות אליו בתוך שיטה כך:

int theAnswer = 42;
System.out.println("The answer to all questions is " + theAnswer);

בשורה השנייה, אתה מדפיס את theAnswer לקונסול באמצעות השיטה המובנית println מחבילת System.out. זהו הדרך הפשוטה ביותר לבדוק משתנה ולוודא שהוא הוגדר כצפוי.

כדי לראות את הקוד בפעולה, השתמש בכלי Java Shell. לאחר התקנת Java, פתח טרמינל או פקודת הפעולה במחשב המקומי שלך והקלד jshell:

jshell

הפלט שלך ייראה דומה לדוגמה הבאה:

Output
|  Welcome to JShell -- Version 11.0.16
|  For an introduction type: /help intro

jshell>

תוכל להדביק את דוגמאות הקוד מהמדריך הזה לקונסול. לאחר השלמת התרגול, תוכל לצאת מ-JShell על ידי הקלדת /exit.

כדי להגדיר ולהשתמש ב-int, הדבק את השורות הבאות לקונסול של jshell:

int theAnswer = 42;
System.out.println("The answer to all questions is " + theAnswer);

תראה את הפלט הבא:

Output
theAnswer ==> 42
The answer to all questions is 42

הפלט הזה מאשר שהגדרת את המשתנה int theAnswer כראוי לערך 42 (theAnswer ==> 42). כמו כן, השתמשת ב־theAnswer בהצבתו בשיטה, והשיטה ייצרה את ערך המשתנה הצפוי.

בוליאני

ערכים בוליאניים הם true או false. ב-Java, תשתמש ב-boolean כדי לאחסן אותם. לדוגמה, ניצור משתנה boolean שמגדיר האם ג'אווה כיף:

boolean isJavaFun = true;

אתה מגדיר את המשתנה isJavaFun כ-true. הערך האלטרנטיבי של boolean הוא false.

על ידי השימוש במשתנה שנתון למעלה, תוכל להדפיס את המשפט ג'אווה כיף: true כך:

boolean isJavaFun = true;
System.out.println("Java is fun: " + isJavaFun);

הרצת השורות הללו ב־jshell תפיק את הפלט הבא:

Output
isJavaFun ==> true
Java is fun: true

דומה לדוגמת ה-int, השיטה println תדפיס את הארגומנט שסופק בסוגריים. סימן הפלוס (+) משלב או מחבר את המחרוזת "ג'אווה כיף: " עם המשתנה isJavaFun כך שמציאותית, זו רק ארגומנט אחד — המחרוזת, ג'אווה כיף: true.

תווים

כדי לאחסן תו אלפאנומרי יחיד, תשתמש ב־char. לדוגמה:

char firstLetter = 'a';

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

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

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

סוגי יצוג

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

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

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

מחלקת String

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

String hello = new String("Hello");

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

לכל מחלקה יש שיטה מיוחדת בשם constructor המשמשת ליצירת אובייקטים חדשים. תוכל לקרוא לבנאי זה על ידי הוספת סוגריים (()) בסוף שם המחלקה. הבנאי יכול לקבל פרמטרים, כפי שבדוגמה למעלה, כאשר הפרמטר "Hello" מיושם על הבנאי של String.

כדי לאמת את ההתנהגות המשתנה hello, עבורו שוב לשיטת println כמו כן:

String hello = new String("Hello");
System.out.println(hello);

הרצת קטעי קוד אלו ב- jshell תצורף את הפלט הבא:

Output
hello ==> "Hello"
Hello

הפעם, הפלט מאשר כי המשתנה hello מוגדר ל- Hello. לאחר מכן, אותו Hello מודפס בשורה חדשה, מאשר את העבודה של שיטת println() עליו.

סוגי מעטפת

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

• Integer: מעטפת לעטיפת ערכים של int.
• Character: מעטפת לעטיפת ערכים של char.
• Boolean: מעטפת לעטיפת ערכים של boolean.

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

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

בדוגמה הבאה, תיצור משתנה של Integer בשם theAnswer עם הערך 42 באמצעות שימוש בשיטת valueOf:

Integer theAnswer = Integer.valueOf(42);
System.out.println(theAnswer);

ב-jshell, תקבל את הפלט הבא:

Output
theAnswer ==> 42
42

בקריאה לשיטת valueOf(42) של Integer, אתה מורה ל-Java ליצור אובייקט עם הערך הזה. מאחורי הקלעים, Java תבדוק האם כבר קיים אובייקט עם ערך כזה במטמון שלה. אם כן, האובייקט יתווסף למשתנה theAnswer. אם לא, ייווצר אובייקט חדש עבור משתנה theAnswer.

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

בנוסף ל־String וּמעטפות, ישנם גם סוגי הפנייה המובנים שימושיים נוספים, שניתן למצוא ב־java.lang סיכום החבילה. כדי להבין באופן מלא כמה מסוגי הפנייה המובנים המתקדמים יותר אלו, נדרשת הסבר נוסף או ידע קודם. לכן נכסה חלק מהם בשיעורים הבאים מסדרת ה־Java שלנו.

ליטרלים

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

ליטרלי סוג פרימיטיבי

כבר השתמשת במספר ליטרלים במקטע על סוגי הפרימיטיביים. עבור כל סוג פרימיטיבי, קיים ליטרל, כמו שלדוגמה מההצגות שלנו: 42, 'a', ו־true. מספרים שלמים כמו 42 הם ליטרלי מספרים שלמים. באופן דומה, תווים כמו 'a' הם ליטרלי תווים, ו־true ו־false הם ליטרלי בוליאניים.

סוגי ערכים פרימיטיביים יכולים גם לשמש ליצירת ערכים עבור סוגי ההפניה. הליטרל int נעשה שימוש ביצירת אובייקט מסוג Integer עם הקוד Integer.valueOf(42). קיימת גם דרך מקיצון עבור זה, וניתן להקצות את הערך ישירות כך:

Integer theAnswer = 42;

42 הוא ליטרל של מספר שלם, בדיוק כמו כל מספר שלם אחר, ואפשר להקצות אותו ישירות למשתנה theAnswer מבלי ציות נוספות. נפוץ לראות הכרזה על אובייקט מסוג Integer כך משום שזה נוח.

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

Boolean isFun = true;

true הוא הליטרל, שמוקצה ישירות למשתנה isFun מסוג Boolean. קיים גם ליטרל של false, שניתן להקצות באותה הדרך.

ליטרל של מחרוזת

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

String helloWorld = "Hello, World!";

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

הליטרל Null

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

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

String initiallyNullString = null;
System.out.println("The class name is: " + initiallyNullString.getClass());

כאשר אתה מנסה להריץ קוד זה ב-jshell, תראה שגיאה דומה לזו:

Output
initiallyNullString ==> null
|  Exception java.lang.NullPointerException
|        at (#4:1)

זה יכול להשתנות לפי מערכת ההפעלה שלך וגרסת ה-Java.

השגיאה java.lang.NullPointerException מושלכת מכיוון שאתה מנסה לקרוא לשיטה getClass() של המחרוזת String על המשתנה initiallyNullString (שמצביע על אובייקט שהוא null).

לטיפול בשגיאה, עליך להקצות מחדש את ערך initiallyNullString כך:

String initiallyNullString = null;
initiallyNullString = "not null any longer";
System.out.println("The class name is: " + initiallyNullString.getClass());

הקוד החדש והתוקן ידפיס את הפלט הבא:

Output
initiallyNullString ==> null
initiallyNullString ==> "not null any longer"
The class name is: class java.lang.String

הפלט לעיל מציין כיצד initiallyNullString הוא בתחילה null, ואז הוא משתנה להיות אובייקט מחרוזת חדש המכיל את "not null any longer". לאחר מכן, כאשר השיטה getClass() מתקראת על האובייקט שנוצר, אתה מקבל java.lang.String, שבו String הוא שם המחלקה ו־java.lang הוא החבילה שלה. לבסוף, מודפסת הודעה מלאה ומשמעותית: "The class name is: class java.lang.String".

הגדרות של ערך null כאלו נפוצות יותר בקוד ישן. הן נעשות כדי ליצור משתנה תחילה ולאחר מכן להקצות לו את הערך האמיתי שלו, לרוב דרך לוגיקה שמקבעת זאת. אך, מאז גרסת Java 8 קיים סוג ההפניה החדש בשם Optional, שנראה כי יותר מתאים למקרים שבהם נעשה שימוש ב־null בעבר.

הפרדת סוג המשתנים ממינוחיהם המקומיים

עד כה, השתמשת בסוגי נתונים רגילים בִּשפת ג'אווה כדי להגדיר משתנים. אך, בג'אווה 10 נוספה תכונה חדשה הנקראת הסקת סוג משתנה מקומי, שמאפשרת לך להשתמש במילת המפתח var לפני משתנה חדש. בעזרת התכונה הזו, ג'אווה תשיג (כלומר, תנחש באופן אוטומטי) את סוג הנתונים מההקשר המקומי. ההסקת סוג מתולכת כיוונית מאחר שהיא מנוגדת לרמת ההגדרה הפורטת של המשתנים שתוארה קודם. היתרונות והחסרונות של תכונה כזו ניתנים לערעור, אך העובדה היא ששפות סטטיות כמו C++ תומכות בהסקת סוג.

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

var hello = "Hello";
System.out.println(hello);

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

Ouput
hello ==> "Hello"
Hello

דוגמה זו תעבוד כל עוד ההתקנה שלך של ג'אווה (ולדי נקודת השמש, JDK) היא מעל גרסה 10. מילת המפתח var לא נתמכת בגרסאות ישנות יותר.

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

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

כדי להראות ש־var יכולה להשתמש רק במשתנים מקומיים, נסה לשים אותה מחוץ לשיטת הראשית, כמו כן:

public class Hello {
	var hello = "Hello";
	public static void main(String[] args) {
		// example code
	}
}

כאשר אתה מדביק את הקוד ל־jshell, תקבל את השגיאה הבאה:

Output
|  Error:
|  'var' is not allowed here
|  	var hello = "Hello";
|   ^-^

var אינה מותרת שם מכיוון ש־hello נמצאת מחוץ לשיטה ולא נחשבת עוד למקומית. לכן, הסקה של סוגים לא עובדת עבור משתנים שאינם מקומיים מכיוון שהקשר לא יכול לשמש באמינות לזיהוי של סוגי הנתונים.

בעוד ששימוש ב־var יכול להיות אתגרני ואינו חובה, ייתכן שתתקל בו, ולכן יש לדעת על זה.

מילות מפתח שמורות

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

int new = 1;

אם תנסה את הדוגמה הזו, תקבל שגיאות ההדמיה מאחר ו־new היא מילת מפתח מורזת.

Output
|  Error:
|  '.class' expected
|  int new = 1;
|      ^
|  Error:
|  <identifier> expected
|  int new = 1;
|         ^
|  Error:
|  '(' or '[' expected
|  int new = 1;
|          ^
|  Error:
|  unexpected type
|    required: value
|    found:    class
|  int new = 1;
|  ^--^
|  Error:
|  missing return statement
|  int new = 1;
|  ^----------^

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

Output
|  Error:
|  '.class' expected
|  int new = 1;
|      ^

השגיאה '.class' צפויה אומרת שכאשר אתה משתמש במילת המפתח new, Java מצפה שייבא קלאס. בנקודה זו, Java לא מסוגלת לפרש את ההצהרה והשגיאות הנוספות נובעות.

שאר מילות המפתח המורזות, כמו abstract, continue, default, for ו־break, גם יש להן משמעויות מסוימות ב-Java ולא ניתן להשתמש בהן כשמות למשתנים. רשימה מלאה של מילות המפתח המורזות ניתן למצוא בדף מילות מפתח בשפת Java. גם אם אין לך זיכרון לכל המילות המפתח, תוכל להשתמש בשגיאות ההדמיה כדי לזהות את הבעיה.

מסקנה

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

למידע נוסף על ג'אווה, בדוק את סדרת כיצד לכתוב בג'אווה שלנו.