Dichiarazione di interruzione in Java

Un saluto a tutti i colleghi e ai semplici interessati. Oggi esamineremo una caratteristica del linguaggio di programmazione Java come l'operatore break. Questo è il primo articolo sul tema degli operatori di transizione, quindi se ti piace sarò felice di scriverne di più. Vorrei sottolineare subito che questo articolo è destinato principalmente agli sviluppatori principianti e gli studenti più avanzati potrebbero non trovare nulla di nuovo per se stessi qui. Quindi andiamo. In Java, ci sono 2 modi per cambiare l'ordine in cui vengono eseguite le istruzioni del programma: istruzioni di salto e meccanismo di gestione delle eccezioni. In Java esistono tre operatori di salto: break, continue e return. Oggi vi invito a dare un'occhiata più da vicino all'operatore break. La gestione delle eccezioni è un argomento così ampio che va oltre lo scopo di questo articolo. Esistono tre modi per utilizzare l'istruzione break in Java. Il primo e più popolare modo è usarlo breakper uscire anticipatamente dal ciclo, ad esempio:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

Questo esempio mostrerà:

1
2
cycle was finished

Ciò significa che quando il contatore del ciclo idiventa uguale al parametro passato number, cioè il numero 3, l'esecuzione del ciclo viene terminata in anticipo. Se il programma ha diversi cicli nidificati, interrompere gli output solo dal ciclo più interno, ad esempio:

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

Questo esempio produce l'output:

012
012
012
012
012
cycles was finished

Come si può vedere dall'esempio, il ciclo interno viene interrotto ogni volta al numero 3 (parametro number) e il ciclo esterno viene eseguito 5 volte, come previsto. In Java è possibile utilizzare più di un'istruzione break all'interno di un ciclo, ma ciò non è consigliabile poiché la leggibilità e la struttura del codice vengono notevolmente degradate. Il secondo utilizzo breakè usarlo per interrompere l'esecuzione delle istruzioni in branch switch, ad esempio:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

L'esecuzione di questo esempio produrrà l'output:

4
after switch

L'istruzione break ha passato il controllo al codice successivo all'intero blocco switch. Se non specifichi breakin switchquesto esempio:

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

L'output non sarà quello previsto:

4
4
after switch

Ciò è accaduto perché dopo l'esecuzione del blocco, case 2il programma ha continuato a eseguire tutti i blocchi case successivi , che ci hanno fornito l'output corrispondente. A volte questa funzionalità dell'operatore switch può essere vantaggiosa per noi, ad esempio:

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

Questo programma confronta un dato numero con il numero 5 e fornisce il seguente output:

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

Quando un metodo viene chiamato per la prima volta, l'operatore switchtrasferisce il controllo all'operatore case 2e poi all'operatore breakin case 5. La seconda chiamata è simile alla prima, ma inizia con c case 7. La terza chiamata non trova un valore adatto tra tutti i casi, quindi l'operatore viene eseguito default. Il terzo modo è utilizzare l'operatore breakinvece dell'operatore gotoC. Per fare ciò, utilizzeremo una forma speciale dell'operatore breakchiamata breakcon un'etichetta. Questo modulo assomiglia break метка;ad un'etichetta: di solito è un nome adatto dallo spazio dei nomi Java, che precede un blocco di codice. Inoltre, dopo aver applicato questo blocco di codice breakcon un'etichetta, il codice continuerà ad essere eseguito dal punto successivo al blocco con l'etichetta corrispondente, ad esempio:

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

Questo esempio produrrà il seguente output:

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

Dopo la prima chiamata al metodo, l'operatore breaktrasferisce il controllo alla fine del blocco secondBlock, uscendo secondBlocke thirdBlock, mentre esegue un altro operatore println()alla fine firstBlock. Dopo la seconda chiamata, tutte le linee vengono visualizzate sullo schermo. Le etichette possono essere utilizzate anche per indicare i cicli. È bene ricordare che su un'etichetta è possibile accedere solo dall'interno del blocco di codice indicato dall'etichetta; ad esempio, tale codice non verrà compilato:

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

Note sulla pulizia del codice e delle istruzioni break: è generalmente accettato il consiglio di usare l'istruzione breakcon molta attenzione, poiché l'uso breakrende il ciclo più difficile da comprendere e costringe il programmatore a guardare all'interno del ciclo per comprendere le sfumature del suo funzionamento. Esiste una regola euristica che break puoi utilizzare con maggiore sicurezza nei cicli più brevi e con maggiore cautela nei cicli lunghi e profondamente annidati, poiché ciò aumenta la probabilità di errori e complica la lettura e la comprensione del tuo codice da parte di altri programmatori. Come ho scritto sopra, l'uso di un gran numero di break.sparsi nel codice indica che il programmatore non comprende appieno il motivo per cui ha scritto il codice in quel modo. Potrebbe valere la pena considerare il refactoring di un ciclo di questo tipo suddividendolo in diversi cicli più piccoli. Cerca di fare attenzione quando usi break un'etichetta in sostituzione di goto, poiché ciò complica la struttura del codice. Questo è tutto ciò che volevo dirti oggi sull'operatore breakin Java. Sarò lieto di critiche costruttive e sono anche pronto a scrivere una continuazione sugli operatori continuee return, se sei interessato.