מתודות ב-Java: איך מגדירים מתודות וקוראים להן

למה מתודות קיימות

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

כבר קראתם למתודות: System.out.println(...) היא קריאה למתודה, וגם list.size(). עכשיו תכתבו מתודות משלכם.

הצהרה על מתודה וקריאה לה

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

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // קוראים לה
        printGreeting();   // קוראים לה שוב
    }
}

נפרק את החלקים של static void printGreeting():

• static: מאפשר ל-main לקרוא לה ישירות בלי ליצור אובייקט (עוד על זה בהמשך).
• void: המתודה הזו לא מחזירה ערך.
• printGreeting: השם שבו קוראים לה.
• (): סוגריים ריקים פירושם שהיא לא מקבלת קלטים.

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

החזרת ערך

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

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) מחושב ל-25, ואפשר לשמור אותו במשתנה, להדפיס אותו או להשתמש בו בביטוי גדול יותר: קריאה למתודה עומדת במקום הערך שהיא מחזירה. ברגע ש-return רץ, המתודה מסתיימת והשליטה חוזרת לקורא. קוד שבא אחרי return באותו מסלול לעולם לא רץ.

טיפוס ההחזרה והערך המוחזר חייבים להתאים: טיפוס הנתונים שמצהירים עליו הוא סוג הערך שהמתודה מתחייבת להחזיר. הצהרה על int וניסיון לכתוב return "text"; היא שגיאת קומפילציה: המהדר אוכף את החוזה.

void מול טיפוס החזרה

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

void logMessage(String msg)   // עושה עבודה, לא מחזירה כלום
int  add(int a, int b)        // מחשבת ערך שהקורא משתמש בו

טעות נפוצה של מתחילים היא לנסות להשתמש ב"תוצאה" של מתודת void:

int x = printGreeting();   // שגיאת קומפילציה: printGreeting() מחזירה void

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

מתודות שמתפצלות ומחזירות מוקדם

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

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

מכיוון שכל return יוצא מיד, התנאי הראשון שמתקיים מנצח. רק ודאו שכל מסלול במתודה שמחזירה ערך מסתיים ב-return: אם ענף כלשהו יכול להגיע לסוף בלי להחזיר, המהדר יתלונן עם "missing return statement". ה-return "F"; האחרון כאן מכסה את המקרה הזה.

מה המשמעות של static כאן

אולי שמתם לב שכל המתודות למעלה הן static. מתודה static שייכת למחלקה עצמה, לא לאובייקט כלשהו, ולכן main (שגם היא static) יכולה לקרוא לה ישירות בשמה. בלי static, המתודה שייכת למופע וצריך אובייקט כדי לקרוא לה.

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

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main היא static, ולכן היא יכולה לקרוא ל-doubleIt ישירות
        System.out.println(doubleIt(21));   // 42
    }
}

משתנים מקומיים נשארים בתוך המתודה

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

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // מקומי ל-sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // error: total לא נראה כאן
    }
}

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

הבא: פרמטרים של מתודות

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