CodeGym /Java Blog /Random-IT /Parola chiave di ritorno Java
John Squirrels
Livello 41
San Francisco

Parola chiave di ritorno Java

Pubblicato nel gruppo Random-IT
Come sappiamo, il linguaggio Java è un linguaggio di programmazione orientato agli oggetti. In altre parole, il concetto fondamentale, cioè il fondamento del fondamento, è che tutto è oggetto. Gli oggetti sono descritti usando le classi. Le classi, a loro volta, definiscono lo stato e il comportamento. Ad esempio, un conto bancario può avere uno stato sotto forma di quantità di denaro nel conto e avere comportamenti che aumentano e diminuiscono il saldo del conto. In Java, i comportamenti vengono implementati tramite metodi. Imparare a definire i metodi arriva proprio all'inizio dei tuoi studi su Java. Ad esempio, nel tutorial ufficiale di Oracle, sotto il titolo " Definizione dei metodi ". Ci sono due cose importanti da prendere in considerazione qui:
  • Ogni metodo ha una firma. La firma consiste nel nome del metodo e nei suoi parametri di input.
  • È necessario specificare un tipo restituito per i metodi. Dichiari il tipo restituito di un metodo nella sua dichiarazione di metodo.
Il tipo restituito non fa parte della firma del metodo. Ancora una volta, questa è una conseguenza del fatto che Java è un linguaggio fortemente tipizzato e il compilatore desidera sapere quali tipi vengono utilizzati e dove, in anticipo e il più possibile. Ancora una volta, questo è per salvarci dagli errori. Fondamentalmente, è tutto per una buona causa. E mi sembra che questo instilli ancora una volta in noi una cultura della gestione dei dati. Quindi, il tipo del valore restituito è specificato per i metodi. E la parola chiave return in Java viene utilizzata per eseguire effettivamente il ritorno. Parola chiave di ritorno Java - 1

Cosa fa return in Java

La parola chiave return è un'istruzione del flusso di controllo, come descritto nell'esercitazione Oracle qui . Puoi anche leggere come restituire i valori nella sezione " Restituzione di un valore da un metodo " del tutorial ufficiale. Il compilatore tiene traccia attentamente se può garantire che il valore restituito di un metodo corrisponda al tipo restituito specificato del metodo. Usiamo l'IDE online di Tutorialspoint per considerare un esempio. Diamo un'occhiata all'esempio primordiale:
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}
Come possiamo vedere, qui viene eseguito il metodo main , che è il punto di ingresso del programma. Le righe di codice vengono eseguite dall'alto verso il basso. Il nostro metodo principale non può restituire un valore. Se proviamo a restituire un valore lì, otterremo un errore: "Errore: il metodo principale deve restituire un valore di tipo void" . Di conseguenza, il metodo emette semplicemente sullo schermo. Ora spostiamo la stringa letterale in un metodo separato per generare il messaggio:
public class HelloWorld {

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

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

}
Come possiamo vedere, abbiamo utilizzato la parola chiave return per indicare il valore restituito, che poi abbiamo passato al metodo println . La dichiarazione del metodo getHelloMessage indica che il metodo restituirà un String . Ciò consente al compilatore di verificare che le azioni del metodo siano coerenti con il modo in cui viene dichiarato. Naturalmente il tipo restituito specificato in una dichiarazione di metodo può essere più ampio del tipo del valore effettivamente restituito nel codice, cioè l'importante è che sia possibile una conversione di tipo. Altrimenti, riceveremo un errore in fase di compilazione: "Errore: tipi incompatibili" . A proposito, probabilmente hai una domanda: perché è il ritornoconsiderata una dichiarazione del flusso di controllo? Perché può interrompere il normale flusso dall'alto verso il basso di un programma. Esempio:
public class HelloWorld {

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

}
Come puoi vedere dall'esempio, interrompiamo il metodo main nel programma Java se viene chiamato senza argomenti. È importante ricordare che se si dispone di codice dopo un'istruzione return , non sarà accessibile. Il nostro compilatore intelligente lo noterà e ti impedirà di eseguire tale programma. Ad esempio, questo codice non compila:
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");
 }
C'è uno sporco trucco per aggirare questo problema. Ad esempio, per scopi di debug o per qualche altro motivo. Il codice sopra può essere risolto racchiudendo l' istruzione return in un blocco if :
if (2==2) {
    return;
}

Istruzione return durante la gestione degli errori

C'è qualcos'altro di molto complicato: possiamo usare return insieme alla gestione degli errori. Voglio dire subito che l'uso di un'istruzione return in un blocco catch è una forma molto, molto brutta, quindi dovresti evitarlo. Ma abbiamo bisogno di un esempio, giusto? Ecco qui:
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);
        }
    }

}
A prima vista, sembra che debba essere restituito 2, poiché infine viene sempre eseguito. Ma no, il valore restituito sarà 1 e la modifica alla variabile nel blocco finally verrà ignorata. Inoltre, supponiamo che value contenga un oggetto e diciamo value = null nel blocco finally . Quindi quell'oggetto, non nullo, verrebbe restituito nel blocco catch . Ma un'istruzione return funzionerebbe correttamente nel blocco finally . Ovviamente, i tuoi colleghi non ti ringrazieranno per le piccole sorprese che riguardano dichiarazioni di ritorno.

void.class

E infine. C'è questo strano costrutto che puoi scrivere: void.class . Hmm. Perché e cosa significa? Esistono davvero vari framework e casi complicati che coinvolgono l' API Java Reflection in cui questo può essere molto utile. Ad esempio, puoi controllare quale tipo restituisce un metodo:
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);
        }
    }
}
Questo può essere utile nei framework di test in cui è necessario sostituire il codice effettivo nei metodi. Ma per fare questo, devi capire come si comporta un metodo (cioè che tipo restituisce). C'è anche un secondo modo per implementare il metodo principale nel codice sopra:
public static void main(String[] args) {
        for (Method method : HelloWorld.class.getDeclaredMethods()) {
            System.out.println(method.getReturnType() == Void.TYPE);
        }
 }
Puoi leggere una discussione piuttosto interessante sulla differenza tra i due su Stack Overflow: qual è la differenza tra java.lang.Void e void?Parola chiave di ritorno Java - 2
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION