Java return nyckelord

Som vi vet är Java-språket ett objektorienterat programmeringsspråk. Med andra ord är det grundläggande konceptet, dvs grunden till grunden, att allt är ett objekt. Objekt beskrivs med hjälp av klasser. Klasser definierar i sin tur tillstånd och beteende. Till exempel kan ett bankkonto ha tillstånd i form av summan pengar på kontot och ha beteenden som ökar och minskar kontosaldot. I Java implementeras beteenden genom metoder. Att lära sig att definiera metoder kommer i början av dina Java-studier. Till exempel i Oracles officiella handledning, under rubriken " Definiera metoder ". Det finns två viktiga saker att notera här:

Varje metod har en signatur. Signaturen består av namnet på metoden och dess inmatningsparametrar.
En returtyp måste anges för metoder. Du deklarerar en metods returtyp i dess metoddeklaration.

Returtypen är inte en del av metodsignaturen. Återigen är detta en konsekvens av att Java är ett starkt typat språk och kompilatorn vill veta vilka typer som används och var, i förväg och så mycket som möjligt. Återigen, detta är för att rädda oss från misstag. I grund och botten är allt för en god sak. Och det förefaller mig som att detta återigen ingjuter i oss en kultur att hantera data. Så typen av returvärde anges för metoder. Och nyckelordet retur i Java används för att faktiskt göra returen. Java retur nyckelord - 1

Vad gör retur i Java

Nyckelordet retur är en kontrollflödessats, som beskrivs i Oracle-handledningen här . Du kan också läsa om hur du returnerar värden i avsnittet " Returnera ett värde från en metod " i den officiella handledningen. Kompilatorn håller noga reda på om den kan säkerställa att en metods returvärde matchar metodens angivna returtyp. Låt oss använda Tutorialspoints online-IDE för att överväga ett exempel. Låt oss titta på det ursprungliga exemplet:

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

Som vi kan se exekveras huvudmetoden här, vilket är programmets ingångspunkt. Kodrader exekveras uppifrån och ned. Vår huvudmetod kan inte returnera ett värde. Om vi försöker returnera ett värde där får vi ett felmeddelande: "Error: Main method must return a value of void" . Följaktligen matas metoden helt enkelt ut till skärmen. Låt oss nu flytta strängen bokstavligt till en separat metod för att generera meddelandet:

public class HelloWorld {

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

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

}

Som vi kan se använde vi nyckelordet return för att indikera returvärdet, som vi sedan skickade till println -metoden. Deklarationen av metoden getHelloMessage indikerar att metoden kommer att returnera en sträng . Detta gör att kompilatorn kan kontrollera att metodens åtgärder stämmer överens med hur den deklareras. Naturligtvis kan returtypen som anges i en metoddeklaration vara bredare än typen av det värde som faktiskt returneras i koden, dvs det viktiga är att en typkonvertering är möjlig. Annars kommer vi att få ett felmeddelande vid kompilering: "Fel: inkompatibla typer" . Förresten, du har förmodligen en fråga: Varför är returanses vara en kontrollflödesbeskrivning? Eftersom det kan störa ett programs normala uppifrån-och-ned-flöde. Exempel:

public class HelloWorld {

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

}

Som du kan se i exemplet avbryter vi huvudmetoden i Java-programmet om den anropas utan argument. Det är viktigt att komma ihåg att om du har kod efter ett returutdrag så kommer den inte att vara tillgänglig. Vår smarta kompilator kommer att märka det och hindra dig från att köra ett sådant program. Till exempel kompilerar den här koden inte:

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

Det finns ett smutsigt hack för att komma runt detta. Till exempel i felsökningssyfte eller av någon annan anledning. Koden ovan kan fixas genom att linda retursatsen i ett if- block:

if (2==2) {
    return;
}

Returnera uttalande under felhantering

Det finns något annat mycket knepigt — vi kan använda retur i samband med felhantering. Jag vill genast säga att det är väldigt, väldigt dåligt att använda en retursats i ett catch-block, så du bör undvika det . Men vi behöver ett exempel, eller hur? Här är det:

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

}

Vid första anblicken verkar det som att 2 bör returneras, eftersom slutligen alltid körs. Men nej, returvärdet kommer att vara 1, och ändringen av variabeln i finally -blocket kommer att ignoreras. Anta dessutom att värdet innehåller ett objekt och vi säger värde = null i finalblocket . Då skulle det objektet, inte null, returneras i fångstblocket . Men ett returmeddelande skulle fungera korrekt i finalblocket . Uppenbarligen kommer dina medarbetare inte att tacka dig för små överraskningar med returutlåtanden.

void.class

Och slutligen. Det finns den här konstiga konstruktionen du kan skriva: void.class . Hmm. Varför och vad betyder det? Det finns verkligen olika ramverk och knepiga fall som involverar Java Reflection API där detta kan vara mycket användbart. Du kan till exempel kontrollera vilken typ en metod returnerar:

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

Detta kan vara användbart i testramverk där du behöver ersätta den faktiska koden i metoder. Men för att göra detta måste du förstå hur en metod beter sig (dvs vilken typ den returnerar). Det finns också ett andra sätt att implementera huvudmetoden i koden ovan:

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

Du kan läsa en ganska intressant diskussion om skillnaden mellan de två på Stack Overflow: Vad är skillnaden mellan java.lang.Void och void?