Mint tudjuk, a Java nyelv egy objektum-orientált programozási nyelv. Vagyis az alapfogalom, vagyis az alapozás alapja, hogy minden tárgy. Az objektumok leírása osztályok segítségével történik. Az osztályok pedig meghatározzák az állapotot és a viselkedést. Például egy bankszámla állapota lehet a számlán lévő pénzösszeg formájában, és olyan viselkedések lehetnek, amelyek növelik vagy csökkentik a számlaegyenleget. A Java-ban a viselkedések metódusokon keresztül valósulnak meg. A módszerek meghatározásának megtanulása a Java-tanulmányok legelején történik. Például az Oracle hivatalos oktatóanyagában, a „ Módszerek meghatározása ” címszó alatt. Itt két fontos dolgot kell figyelembe venni:
  • Minden módszernek van aláírása. Az aláírás a metódus nevéből és bemeneti paramétereiből áll.
  • A metódusokhoz meg kell adni egy visszatérési típust. A metódus visszatérési típusát deklarálja a metódus deklarációjában.
A visszatérési típus nem része a metódus aláírásának. Ez megint annak a következménye, hogy a Java erősen tipizált nyelv, és a fordító szeretné tudni, hogy milyen típusokat és hol, előre és amennyire csak lehetséges. Ez megint csak azért van, hogy megóvjunk minket a hibáktól. Alapvetően mindez egy jó ügy érdekében. És számomra úgy tűnik, hogy ez ismét belénk ülteti az adatkezelés kultúráját. Tehát a metódusokhoz meg van adva a visszatérési érték típusa. A Java return kulcsszót pedig a visszatérés tényleges elvégzésére használják. Java visszatérési kulcsszó - 1

Mit csinál a return a Java-ban

A return kulcsszó egy control flow utasítás, az Oracle oktatóanyagának leírása szerint itt . Az értékek visszaadásáról a hivatalos oktatóanyag " Érték visszaadása módszerből " című részében olvashat . A fordító gondosan nyomon követi, hogy biztosítani tudja-e, hogy a metódus visszatérési értéke megegyezzen a metódus megadott visszatérési típusával. Használjuk a Tutorialspoint Online IDE-jét egy példa megfontolására. Nézzük az ősi példát: 

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}
Amint látjuk, itt fut le a fő metódus, amely a program belépési pontja. A kódsorokat felülről lefelé hajtják végre. Fő módszerünk nem tud értéket visszaadni. Ha megpróbálunk ott értéket visszaadni, akkor hibaüzenetet kapunk: "Hiba: A fő metódusnak void típusú értéket kell visszaadnia" . Ennek megfelelően a módszer egyszerűen kiírja a képernyőt. Most helyezzük át a karakterlánc literált egy külön módszerbe az üzenet generálására: 

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println(getHelloMessage());
    }
    
    public static String getHelloMessage() {
        return "Hello World";
    }
    
}
Amint látjuk, a return kulcsszóval jeleztük a visszatérési értéket, amit aztán átadtunk a println metódusnak. A getHelloMessage metódus deklarációja azt jelzi, hogy a metódus egy String-et ad vissza . Ez lehetővé teszi a fordító számára, hogy ellenőrizze, hogy a metódus műveletei összhangban vannak-e a deklarációval. Természetesen a metódus deklarációban megadott visszatérési típus szélesebb lehet, mint a kódban ténylegesen visszaadott érték típusa, vagyis az a fontos, hogy lehetséges legyen a típuskonverzió. Ellenkező esetben fordításkor hibát fogunk kapni: "Hiba: nem kompatibilis típusok" . Mellesleg, valószínűleg van egy kérdésed: Miért van visszatérésellenőrzési folyamat utasításnak tekinthető? Mert ez megzavarhatja a program normál felülről lefelé haladását. Példa: 

public class HelloWorld {

    public static void main(String[] args) {
        if (args.length == 0) {
            return;
        }
        for (String arg : args) {
            System.out.println(arg);
        }
    }
    
}
Amint a példából látható, a Java programban megszakítjuk a fő metódust, ha argumentumok nélkül hívják meg. Fontos megjegyezni, hogy ha a return utasítás után van kódja, akkor az nem lesz elérhető. Az intelligens fordítóprogramunk észreveszi, és megakadályozza, hogy ilyen programot fusson. Például ez a kód nem fordítja le: 

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");
 }
Van egy piszkos hack, hogy ezt megkerüljük. Például hibakeresés céljából, vagy más okból. A fenti kód javítható, ha a return utasítást egy if blokkba csomagolja: 

if (2==2) {
    return;
}

Return nyilatkozat hibakezelés során

Van még valami nagyon trükkös – használhatjuk a return-t a hibakezeléssel együtt. Azonnal szeretném elmondani, hogy a return utasítás használata catch blokkban nagyon-nagyon rossz forma, ezért kerülje el. De kell egy példa, nem? Itt van: 

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);
        }
    }
    
}
Első pillantásra úgy tűnik, hogy a 2-t vissza kell adni, mivel végül mindig végrehajtódik. De nem, a visszatérési érték 1 lesz, és a rendszer figyelmen kívül hagyja a végső blokk változójának módosítását . Sőt, tegyük fel, hogy az érték tartalmaz egy objektumot, és a végső blokkban azt mondjuk, hogy value = null . Ekkor ez az objektum, nem pedig null, kerül visszaadásra a catch blokkban. De a return utasítás helyesen működne a Végül blokkban. Nyilvánvaló, hogy munkatársai nem fogják megköszönni a visszáru nyilatkozatokkal kapcsolatos apró meglepetéseket.

semmis.osztály

És végül. Van egy furcsa konstrukció, amit írhatsz: void.class . Hmm. Miért és mit jelent? Valójában vannak különféle keretrendszerek és trükkös esetek a Java Reflection API-val kapcsolatban , ahol ez nagyon hasznos lehet. Például ellenőrizheti, hogy egy metódus milyen típust ad vissza: 

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);
        }
    }
}
Ez hasznos lehet olyan tesztkeretrendszerekben, ahol le kell cserélni a tényleges kódot a metódusokban. Ehhez azonban meg kell értened, hogyan viselkedik egy metódus (vagyis milyen típust ad vissza). Van egy másik módja is a fő módszer megvalósításának a fenti kódban: 

public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }
Elég érdekes vitát olvashat a kettő közötti különbségről a Stack Overflow oldalon: Mi a különbség a java.lang.Void és a void között?