Java Syntax: מחלקות, מתודות, פקודות וסוגריים מסולסלים

איך נראית תוכנית Java

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

הנה תוכנית Java השלמה הקטנה ביותר. הריצו אותה:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java");
    }
}

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

הכול נמצא בתוך מחלקה

ב-Java אין קוד "חופשי" שמרחף ברמה העליונה של הקובץ. כל הקוד נמצא בתוך מחלקה, שמוצהרת עם מילת המפתח class ושם:

public class Main {
    // everything goes in here
}

ה-{ הפותח וה-} הסוגר שמתאים לו מסמנים את גוף המחלקה. את השם Main אתם בוחרים, עם כלל חשוב אחד: בקובץ .java רגיל, מחלקה public חייבת להתאים בדיוק לשם הקובץ. public class Main שייכת לקובץ Main.java. טעות באותיות גדולות וקטנות, והקומפיילר מסרב לבנות אותה.

מה הן מחלקות באמת תלמדו בפרק על מחלקות. בינתיים, התייחסו ל-public class Main { ... } כעטיפה הנדרשת סביב הקוד שלכם.

מתודת main היא קו הזינוק

כשמריצים תוכנית Java, סביבת הריצה מחפשת מתודה מסוימת אחת כדי להתחיל את ההרצה:

public static void main(String[] args) {
    // your code starts here
}

על החתימה הזו אין מה להתווכח. כל מילה עושה עבודה:

• public: סביבת הריצה יכולה להגיע אליה מחוץ למחלקה.
• static: היא רצה בלי ליצור קודם אובייקט של המחלקה.
• void: היא לא מחזירה כלום כשהיא מסיימת.
• main: השם המדויק שסביבת הריצה מחפשת.
• String[] args: מערך של ארגומנטים משורת הפקודה שהועברו לתוכנית.

אם אפילו מילה אחת לא נכונה, Static במקום static או String args במקום String[] args, הקוד עדיין עלול להתקמפל, אבל ההפעלה נכשלת עם Error: Main method not found in class Main. ההודעה הזו כמעט תמיד מצביעה על שגיאת הקלדה בשורה הזו.

פקודות מסתיימות בנקודה-פסיק

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

public class Main {
    public static void main(String[] args) {
        int score = 90;
        score = score + 5;
        System.out.println(score);
    }
}

כיוון שירידות שורה לא נחשבות, שלוש הפקודות יכלו לשבת בשורה אחת ועדיין לעבוד, למרות שאף אחד לא כותב Java ככה:

int score = 90; score = score + 5; System.out.println(score);

שכחתם נקודה-פסיק? הקומפיילר עוצר אתכם לפני שהתוכנית רצה:

int score = 90
System.out.println(score);

error: ';' expected
        int score = 90
                      ^

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

בלוקים וסוגריים מסולסלים

סוגריים מסולסלים { } מקבצים פקודות לבלוק. גוף של מחלקה הוא בלוק, גוף של מתודה הוא בלוק, וגם הגוף של if או של לולאה הוא בלוק. בלוקים יכולים להיות מקוננים בתוך בלוקים:

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

        if (hour < 12) {
            System.out.println("Good morning");
            System.out.println("Time to code");
        }
    }
}

שימו לב להבדל מפקודות: שורה שפותחת בלוק מסתיימת ב-{, לא בנקודה-פסיק, ולא שמים נקודה-פסיק אחרי ה-} שסוגר מתודה, מחלקה, if או לולאה. בלבול בזה הוא טעות קלאסית של ההתחלה:

public static void main(String[] args) {
    System.out.println("hi");
}; // <- this semicolon is unnecessary (and after a class/method, wrong)

ההזחה בדוגמאות היא רק בשביל בני אדם. Java מתעלמת ממנה, אבל הזחה עקבית היא הדרך שלכם ושל כל השאר לעקוב איזה { מתאים לאיזה }. תנו לעורך להזיח אוטומטית, והסוגריים יסתדרו לבד.

Java רגישה לאותיות גדולות וקטנות

Java מתייחסת לאותיות גדולות וקטנות כשונות לגמרי. score, Score ו-SCORE הם שלושה שמות נפרדים. אותו דבר נכון למילות מפתח ולשמות מובנים:

public class Main {
    public static void main(String[] args) {
        String name = "Ada";
        System.out.println("Hello, " + name);
    }
}

אם הייתם כותבים system.out.println (עם s קטנה) או String Name ואז מנסים להשתמש ב-name, הקומפיילר היה דוחה את זה. כמה שמות שמתחילים כותבים לעתים קרובות עם אותיות לא נכונות:

• System: עם S גדולה. system.out.println(...) לא יתקמפל.
• String: עם S גדולה. זו מחלקה, בניגוד לטיפוסים הפרימיטיביים שנכתבים באותיות קטנות.
• void, int, public, static: כולם באותיות קטנות. אלה מילות מפתח.

רוב שגיאות "cannot find symbol" נובעות מטעות באותיות גדולות וקטנות. השגיאה אפילו אומרת לכם איזה סמל היא לא מצאה: השוו את האותיות שלו למה שהקלדתם.

מחברים את החלקים

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

public class Main {
    public static void main(String[] args) {
        String city = "Lisbon";
        int temperature = 24;

        System.out.println("City: " + city);
        System.out.println("Temp: " + temperature + "C");

        if (temperature > 20) {
            System.out.println("Warm enough for shorts");
        }
    }
}

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

הבא בתור: הערות

עכשיו אתם יודעים לקרוא את המבנה של קובץ Java. הדבר הבא שמוסיפים הוא הערות לבני אדם: טקסט שהקומפיילר מתעלם ממנו לגמרי. העמוד הבא עוסק בהערות: צורת השורה הבודדת //, צורת הבלוק /* */, ומתי הערה באמת מצדיקה את מקומה בקוד.