הצהרת החזרה ב-Java

מבוא

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

• לכל שיטה יש חתימה. החתימה מורכבת משם השיטה ופרמטרי הקלט שלה;
• שיטות חייבות לציין סוג החזרה;
• סוג ההחזרה אינו חלק מחתימת השיטה.

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

הצהרת החזרת מילות מפתח ב-Java

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

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

כפי שאנו יכולים לראות, כאן מבוצעת שיטה main, שהיא נקודת הכניסה לתוכנית. שורות קוד מבוצעות מלמעלה למטה. השיטה שלנו mainלא יכולה להחזיר ערכים, אחרת נקבל שגיאה: " Error: Main method must return a value of type void". לכן, השיטה פשוט תוציא פלט למסך. כעת נעביר את קבלת המחרוזת לשיטה נפרדת לקבלת ההודעה:

public class HelloWorld {

    public static void main(String []args) {
        System.out.println(getHelloMessage());
    }

    public static String getHelloMessage() {
        return "Hello World";
    }

}

כפי שאנו יכולים לראות, באמצעות מילת המפתח returnציינו את ערך ההחזרה, בו השתמשנו בהמשך השיטה println. בתיאור (הגדרה) של השיטה, getHelloMessageציינו שהיא תחזיר לנו String. זה מאפשר למהדר לבדוק שפעולות השיטה עולות בקנה אחד עם האופן שבו היא מוצהרת. מטבע הדברים, סוג ערך ההחזרה שצוין בהגדרת השיטה יכול להיות רחב יותר מסוג הערך המוחזר מהקוד, כלומר. העיקר שהסוגים מצטמצמים זה לזה. אחרת נקבל שגיאת זמן קומפילציה: " error: incompatible types". אגב, כנראה מיד עלתה השאלה: למה returnזה חל על מפעילי בקרת זרימת תוכניות? אבל בגלל שזה יכול לשבש את הזרימה הרגילה של התוכנית מלמעלה למטה. לדוגמה:

public class HelloWorld {

    public static void main(String []args){
        if (args.length == 0)  {
            return;
        }
        for (String arg : args)  {
            System.out.println(arg);
        }
    }

}

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

public static void main(String []args) {
        System.out.println("1");
        return;
        System.out.println("2");
 }

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

if (2==2)  {
    return;
}

הצהרת החזר בטיפול בשגיאות

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

public class HelloWorld  {

    public static void main(String []args) {
        System.out.println("Value is: " + getIntValue());
    }

    public static int getIntValue()  {
        int value = 1;
        try {
            System.out.println("Something terrible happens");
            throw new Exception();
        } catch (Exception e) {
            System.out.println("Catched value: " + value);
            return value;
        } finally {
            value++;
            System.out.println("New value: " + value);
        }
    }

}

במבט ראשון נראה שצריך להחזיר 2, כי finallyזה תמיד מבוצע. finallyאבל לא, הערך יהיה 1, ויתעלם מהשינוי למשתנה ב . יתרה מכך, אם הוא valueהכיל אובייקט ואמרנו finally, value = nullאז הוא catchעדיין יחזיר הפניה לאובייקט, לא null. אבל מהחסימה finallyהמפעיל returnהיה עובד כמו שצריך. עמיתים בבירור לא יודו לך על מתנה כזו.

void.class

ולבסוף. אתה יכול לכתוב קונסטרוקציה מוזרה כמו void.class. נראה, למה ומה הטעם? למעשה, במסגרות שונות ובמקרים מסובכים שבהם נעשה שימוש ב-Java Reflection API , זה עשוי להיות נחוץ מאוד. לדוגמה, אתה יכול לבדוק איזה סוג שיטה מחזירה:

import java.lang.reflect.Method;

public class HelloWorld {

    public void getVoidValue() {
    }

    public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == void.class);
        }
    }
}

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

public static void main (String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }

דיון מעניין למדי על ההבדל ביניהם ניתן לקרוא ב-stackoverflow: מה ההבדל בין java.lang.Void ל-void? #ויאצ'סלב