Java החזר מילת מפתח

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

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

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

מה החזרה עושה בג'אווה

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

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

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

public class HelloWorld {

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

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

}

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

public class HelloWorld {

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

}

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

public static void main(String[] args) {
        System.out.println("1");
        return;
// we use output method after return statement, which is incorrect
        System.out.println("2");
 }

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

if (2==2) {
    return;
}

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

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

public class HelloWorld {

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

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

}

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

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);
        }
    }
}

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

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

אתה יכול לקרוא דיון די מעניין על ההבדל בין השניים ב-Stack Overflow: מה ההבדל בין java.lang.Void ל-void?