Operatori di salto

Java supporta tre operatori di salto break: continuee return. Trasferiscono il controllo a un'altra parte del tuo programma. Consideriamo ciascuno degli operatori in dettaglio.

Utilizzando l'operatorebreak

L'operatore breakin Java viene utilizzato in tre casi. Innanzitutto, come hai già visto, termina la sequenza di istruzioni nei rami delle istruzioni switch. In secondo luogo, può essere utilizzato per uscire da un ciclo. In terzo luogo, può essere utilizzato come forma "civilizzata" dell'operatore di salto incondizionato goto. Questa sezione spiega gli ultimi due casi. Utilizzare breakper uscire da un ciclo Utilizzando break, è possibile forzare la terminazione immediata del ciclo, ignorando l'espressione condizionale e qualsiasi codice rimanente nel corpo del ciclo. Quando si incontra un'istruzione breakall'interno di un ciclo, la seconda termina e il controllo del programma viene trasferito all'istruzione che la segue. Esempio semplice:

// Использование break для выхода из цикла.
public class BreakLoop {

  public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
      if (i == 4) {
        break; // завершить цикл, если i = 4
      }
      System.out.println("i: " + i);
    }
    System.out.println("Цикл завершен.");
  }
}

Questo programma genera il seguente output:

i: 0
i: 1
i: 2
i: 3
Цикл завершен.

Sebbene il ciclo forsia qui progettato per eseguire le sue istruzioni da 0 a 99 volte, l'operatore breakne fa terminare anticipatamente quando i è 4. L'operatore breakpuò essere utilizzato con qualsiasi ciclo di Java, compresi i cicli intenzionalmente infiniti. Ad esempio, di seguito è riportato il programma precedente codificato utilizzando un loop while. L'output di questo programma è lo stesso del suo predecessore.

// Использование break для выхода из while-цикла.
public class BreakLoop2 {

  public static void main(String[] args) {
    int i = 0;
    while (i < 100) {
      if (i == 4) {
        break; // закончить цикл, если i = 4
      }
      System.out.println("i: " + i);
      i++;
    }
    System.out.println("Цикл завершен.");
  }
}

Se utilizzata all'interno di una serie di cicli nidificati, l'istruzione breakuscirà solo dal ciclo più interno. Per esempio:

// Использование break во вложенных циклах.
public class BreakLoop3 {

  public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 10; j++) {
        if (j == 4) {
          break; // закончить цикл, если j = 4
        }
        System.out.print(j + " ");
      }
      System.out.println();
    }
    System.out.println("Цикл завершен.");
  }
}

Questo programma genera il seguente output:

Итерация 0: 0 1 2 3
Итерация 1: 0 1 2 3
Итерация 2: 0 1 2 3
Цикл завершен.

Come puoi vedere, l'istruzione breaknel ciclo interno fa terminare solo quel ciclo. Il circuito esterno non è interessato. Facciamo ancora due osservazioni riguardo break. Innanzitutto, possono apparire più istruzioni in un ciclo break. Tuttavia, fai attenzione. Troppi di loro tendono a destrutturare il tuo codice. In secondo luogo, break, che termina l'operatore - switch, influisce solo sull'operatore - specificato switch(e non sui cicli che lo includono). Commento: Breaknon è stato progettato come un normale mezzo di terminazione del circuito. Questo scopo è servito dall'espressione condizionale dell'intestazione del ciclo. L'operatore breakdovrebbe essere utilizzato solo per interrompere il loop quando si verificano determinate situazioni speciali.

Utilizzare breakcome modulogoto

Oltre ad essere utilizzato nelle istruzioni e nei cicli switch , breakpuò anche essere utilizzato da solo come forma "civilizzata" del goto. Java non contiene l'operatore gotoperché esegue il ramo in modo arbitrario e non strutturato. Il codice che utilizza .intensamente gotoè in genere difficile da comprendere e gestire. Inoltre sovrascrive alcune ottimizzazioni del compilatore. Esistono, tuttavia, diversi punti di un programma in cui gotoil flusso di controllo è un costrutto prezioso e legittimo. Ad esempio, gotopuò essere utile quando si esce da una serie di cicli profondamente annidati. Per gestire tali situazioni, Java definisce una forma estesa dell'operatore break. Usandolo, puoi uscire da uno o più blocchi di codice. Non è necessario che questi blocchi facciano parte di un ciclo o di un'istruzione switch. Può trattarsi di qualsiasi blocco. Successivamente, puoi determinare esattamente dove continuerà l'esecuzione perché questo modulo breakfunziona con il marchio e fornisce i vantaggi di goto, aggirandone i problemi. Un'istruzione breaketichettata ha la seguente forma generale: break label; Ecco labelil nome di un'etichetta che identifica un blocco di codice. Quando questa forma breakviene eseguita, il controllo viene trasferito dal blocco di codice denominato (la cui etichetta è specificata nell'istruzione break) all'istruzione che segue quel blocco. Un blocco di codice marcato deve necessariamente includere questa istruzione break, ma non è obbligatorio che tale inclusione sia diretta (cioè breakpuò essere incluso non direttamente in un blocco con una propria etichetta, ma in un blocco annidato al suo interno, eventualmente anch'esso marcato ). Ciò significa che puoi utilizzare un operatore contrassegnato breakper uscire da un insieme di blocchi nidificati. Ma non puoi utilizzare breakun blocco di codice che non includa un file break. Per nominare un blocco, posiziona un'etichetta all'inizio del blocco (prima della parentesi graffa di apertura). Un'etichetta è un qualsiasi identificatore Java valido seguito da due punti. Dopo aver etichettato un blocco, la sua etichetta può essere utilizzata come argomento per l'operatore break. Ciò farà sì che l'esecuzione continui dalla fine del blocco contrassegnato. Ad esempio, il seguente programma contiene tre blocchi annidati, ciascuno con la propria etichetta. L'operatore breakavanza, oltre la fine del blocco contrassegnato con l'etichetta second, saltando due operatori println().

// Использование break How цивorзованной формы goto.
public class Break {

  public static void main(String[] args) {
    boolean t = true;
    first:
    {
      second:
      {
        third:
        {
          System.out.println("Перед оператором break.");
          if (t) {
            break second; // выход из блока second
          }
          System.out.println("Данный оператор никогда не выполнится");
        }
        System.out.println("Данный оператор никогда не выполнится ");
      }
      System.out.println("Данный оператор размещен после блока second.");
    }
  }
}

L'esecuzione di questo programma genera il seguente output:

Перед оператором break.
Данный оператор размещен после блока second.

Uno degli usi più comuni dell'operatore etichettato breakè quello di sfuggire ai cicli nidificati. Ad esempio, nel seguente programma il ciclo esterno viene eseguito solo una volta:

// Использование break для выхода из вложенных циклов.
public class BreakLoop4 {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
      for (int j = 0; j < 100; j++) {

        if (j == 10) {
          break outer; // выйти из обоих циклов
        }
        System.out.print(j + " ");
      }
      System.out.println("Эта строка никогда не будет выведена");
    }
    System.out.println("Цикл завершен.");
  }
}

Il programma genera il seguente output:

Итерация 0: 0 1 2 3 4 5 6 7 8 9 Цикл завершен.

È facile vedere che quando il ciclo interno viene interrotto prima della fine di quello esterno, entrambi i cicli terminano. Tieni presente che non puoi eseguire breakun salto a qualsiasi etichetta che non sia definita per il blocco che la racchiude. Ad esempio, il seguente programma non è valido e non verrà compilato:

// Эта программа содержит ошибку.
public class BreakErr {

  public static void main(String[] args) {
    one:
    for (int i = 0; i < 3; i++) {
      System.out.print("Итерация " + i + ": ");
    }
    for (int j = 0; j < 100; j++) {
      if (j == 10) {
        break one; //He верно!
      }
      System.out.print(j + " ");
    }
  }
}

Poiché un ciclo contrassegnato come uno non include un'istruzione break, non è possibile trasferire il controllo a questo blocco.

Utilizzando l'operatorecontinue

A volte è utile avviare anticipatamente l'iterazione successiva di un ciclo. Cioè, devi continuare a eseguire il ciclo, ma interrompere l'elaborazione del resto del codice nel suo corpo per questa particolare iterazione. In realtà, questa è una gototransizione dalle successive operazioni del corpo fino alla fine del blocco del ciclo. Questa azione viene eseguita dall'operatore continue. Nei cicli, l' operatore whilee fa sì che il controllo venga trasferito direttamente all'espressione condizionale che controlla il ciclo. In un ciclo, il controllo passa prima alla parte iterativa dell'istruzione e poi all'espressione condizionale. Per tutti e tre i cicli, qualsiasi codice intermedio viene ignorato. Di seguito è riportato un programma di esempio che utilizza per stampare due numeri su ciascuna riga: do whilecontinueforforcontinue

// Демонстрирует continue.
public class Continue {

  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      System.out.print(i + " ");
      if (i % 2 == 0) {
        continue;
      }
      System.out.println("");
    }
  }
}

Questo codice utilizza l'operazione %(modulo) per verificare se qualcosa è ipari. In tal caso, il ciclo continua senza stampare un carattere di nuova riga. Uscita del programma:

0 1
2 3
4 5
6 7
8 9

Come con l'operatore break, continueè possibile definire un'etichetta che indica quale ciclo di inclusione continuare. Un programma di esempio che utilizza continueper stampare una tavola pitagorica triangolare da 0 a 9.

// Использование continue с меткой.
public class ContinueLabel {

  public static void main(String[] args) {
    outer:
    for (int i = 0; i < 10; i++) {
      for (int j = 0; j < 10; j++) {
        if (j > i) {
          System.out.println();
          continue outer;
        }
        System.out.print(" " + (i * j));
      }
    }
    System.out.println();
  }
}

L'istruzione continuein questo esempio termina il ciclo di valutazione je continua con l'iterazione successiva del ciclo guidata da i. Output da questo programma:

0
 0 1
 0 2 4
 0 3 6 9
 0 4 8 12 16
 0 5 10 15 20 25
 0 6 12 18 24 30 36
 0 7 14 21 28 35 42 49
 0 8 16 24 32 40 48 56 64
 0 9 18 27 36 45 54 63 72 81

È estremamente raramente utile continue. Uno dei motivi è che Java fornisce un ricco insieme di istruzioni in loop adatte alla maggior parte delle applicazioni. Tuttavia, per quelle situazioni speciali in cui è necessario terminare anticipatamente l'iterazione, la dichiarazione continuefornisce un modo strutturato per eseguire questa attività.

Operatorereturn

L'ultima istruzione di controllo è return. Viene utilizzato per restituire esplicitamente un metodo, ovvero trasferisce nuovamente il controllo del programma al programma chiamante. L'operatore returnè classificato come operatore di transizione. Sebbene la discussione completa debba attendere la discussione dei metodi, qui viene fornita una breve panoramica return. L'operatore returnpuò essere utilizzato ovunque in un metodo per tornare al programma che chiama il metodo. L'istruzione returntermina immediatamente l'esecuzione del metodo in cui si trova. L'esempio seguente illustra ciò:

// Демонстрирует return.
public class Return {

  public static void main(String[] args) {
    boolean t = true;
    System.out.println("Перед оператором return.");
    if (t) {
      return; // возврат в вызывающую программу
    }
    System.out.println("Этот оператор никогда не выполнится.");
  }
}

Questo returnritorna al sistema Java in fase di esecuzione, poiché è il sistema che chiama main(). Risultato da questo programma:

Перед оператором return.

Potresti notare che l'istruzione finale println()non viene eseguita. Al momento dell'esecuzione, returnil controllo viene trasferito nuovamente al programma chiamante. Un'ultima nota. Nel programma precedente l' ifoperatore (t) è necessario. Senza di esso, il compilatore Java genererebbe un errore di "codice irraggiungibile" perché saprebbe che l'ultima istruzione println()non verrebbe mai eseguita. Per prevenire questo errore, viene utilizzato l'operatore (t) ifche inganna il compilatore per il bene di questa dimostrazione. Collegamento alla fonte originale: operatori di transizione