Traccia dello stack Java

La Java Virtual Machine (di seguito JVM) elabora il codice ed esegue i metodi uno dopo l'altro, iniziando dal metodo main. Quando raggiunge il metodo successivo, dice che questo metodo è in cima allo stack. Dopo che un metodo è stato completamente eseguito, viene rimosso dallo stack e sostituito da quello successivo nella coda. Per dimostrare il principio, digitare questo codice:

package errorhandling;

public class errorChecking {
    public static void main(String[] args) {
        System.out.println("Метод Main успешно запущен");
        m1();
        System.out.println("Метод Main заканчивает свою работу");
    }

    static void m1() {
        System.out.println("Первый метод передаёт привет!(m1)");
        m2();
    }

    static void m2() {
        System.out.println("Второй метод передаёт привет(m2)");
    }
}

Abbiamo tre metodi: metodo main, metodo m1e metodo m2. All'avvio del programma, il metodo si trova in cima allo stack main. All'interno del metodo main, il metodo viene chiamato m1. Quando viene chiamato, salta in cima allo stack. Il metodo m1a sua volta chiama il metodo m2. Ora il metodo m2salta in cima allo stack, rimuovendo temporaneamente m1. Immaginatelo per un secondo: mainsopra m1e sopra m2! Avendo fatto i suoi affari, m2finisce e il controllo ritorna a m1. Anche il metodo m1, una volta completato, viene rimosso dallo stack e il controllo viene nuovamente assegnato al metodo main. Esegui il tuo programma e guarda la finestra di output: Il metodo Main viene eseguito con successo Il primo metodo dice ciao!(m1) Il secondo metodo dice ciao(m2) Il metodo Main termina Se qualcosa va storto nel metodo m2, la JVM (Java Virtual Machine ), te lo ricordi, vero?) cercherà i gestori degli errori, ad esempio un block try … catch. Se non sono presenti errori nel m1metodo del gestore errori, l'eccezione verrà passata al metodo m1, nella speranza che sia in grado di gestirla. Se non rileva un gestore di errori qui, l'eccezione si sposterà nuovamente nello stack, questa volta nel metodo main. Se il metodo mainnon rileva l'eccezione, verrà stampato uno strano messaggio di errore nella finestra di output. Ad esempio, rendi il tuo metodo m2simile a questo:

static void m2() {
    int x = 10;
    int y = 0;
    double z = x / y;
    System.out.println( z );
    System.out.println("Method Two - m2");
}

Questo metodo contiene una divisione per zero errori. Ecco la versione completa del programma, verifica con il tuo:

package errorhandling;

public class errorChecking {
    public static void main(String[] args) {
        System.out.println("Метод Main успешно запущен");
        m1();
        System.out.println("Метод Main заканчивает свою работу");
    }

    static void m1() {
        System.out.println("Первый метод передаёт привет!(m1)");
        m2();
    }

    static void m2() {
        int x = 10;
        int y = 0;
        double z = x / y;
        System.out.println( z );
        System.out.println("Method Two - m2");
    }
}

Esegui il programma e guarda cosa ti dà la finestra di output: Il metodo Main è stato eseguito con successo Il primo metodo dice ciao!(m1) Eccezione nel thread "main" java.lang.ArithmeticException: / per zero in errorhandling.errorChecking.m2(<u >errorChecking.java:17</u>) in errorhandling.errorChecking.m1(<u>Solution.java:11</u>) in errorhandling.errorChecking.main(<u>>Solution.java:5</u >) Processo terminato con codice di uscita 1 Stai guardando qualcosa chiamato stack trace. Le tre righe sottolineate in blu si riferiscono ai tuoi metodi e possono essere trovate in: Name_пакета.Name_класса.Name_метода La prima riga dall'alto è dove si è verificato l'errore - nel metodo m2. Java ha assicurato che fosse gestito in modo ArithmeticExceptiontale da rilevare la divisione per zero errori. Non è presente alcun gestore degli errori nei metodi e m2. Quindi il programma lo ha elaborato con il gestore errori predefinito. Cambia il tuo metodo nel seguente: m1mainm1

try {
    System.out.println("Первый метод передаёт привет!(m1)");
    m2( );
}
catch (ArithmeticException err) {
    System.out.println(err.getMessage());
}

Ora abbiamo racchiuso il metodo m2in un blocco try. In parte catch, utilizziamo il tipo di eccezione rilevata nell'analisi dello stack: ArithmeticException. Esegui nuovamente il codice e vedrai quanto segue nella finestra di output: Il metodo Main è stato eseguito correttamente Il primo metodo dice ciao!(m1) / by zero Il metodo Main termina Notare che il messaggio di errore è stato stampato come: " / by zero " . Il metodo m2non è stato eseguito completamente, ma è stato interrotto quando si è verificato un errore. Il controllo è stato poi ritrasferito m1. Ciò è accaduto perché il blocco catchstesso ha riconosciuto l'errore; la JVM non ha contattato il gestore degli errori standard, ma ha visualizzato un messaggio situato tra le parentesi graffe del blocco catch. Tieni presente che il programma stesso non è stato interrotto. Il controllo, come al solito, è andato al metodo mainda cui m1è stato chiamato. E l'ultima riga del metodo mainè stata in grado di visualizzare " Metodo End Main ". Questo è molto, molto importante. Se ti serviva il valore da m1, per il lavoro successivo da qualche parte in main. E se il valore non è presente, il tuo programma potrebbe non funzionare come previsto. Quando vedi l'analisi dello stack nella finestra di output, sappi solo che la prima riga è dove si è verificato il problema e le righe rimanenti (se ce ne sono ovviamente) sono dove l'eccezione è stata propagata nello stack, di solito terminando con main. Traduzione da homeandlearn.co.uk Ringraziamo: Sergei Sysoev, Treefeed...