Impara Istruzione Switch-Case

Scorri per mostrare il menu

Gestione di Molteplici Condizioni Diverse

Quando dobbiamo verificare molte condizioni, utilizzare catene di if-else può non essere conveniente.

Ad esempio:

Main.java


              12345678910111213141516171819
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // You can change the value of the variable `a` to test the `if` statement
        int a = 30;
        if (a == 10) {
            System.out.println(10);
        } else if (a == 20) {
            System.out.println(20);
        } else if (a == 30) {
            System.out.println(30);
        } else if (a == 40) {
            System.out.println(40);
        } else {
        	System.out.println(a);
		}
    }
}

Possiamo notare che questo approccio non appare ordinato né professionale. In questi casi, Java mette a disposizione l'istruzione switch-case.

Istruzione switch-case

L'istruzione switch-case è composta da diverse parti:

Main.java


              123456789
            
switch (expression) {
    case value_1: // Code to be executed if expression matches `value_1`
        break; // Break is used to exit the `switch` statement.
    case value_2: // Code to be executed if expression matches `value_2`
        break; // Break is used to exit the `switch` statement.
    ............
    default: // Code to be executed if no cases match
    // Optional, but executed if no other case matches
}

Nel codice sopra, si può vedere che utilizziamo i blocchi switch per eseguire selettivamente delle operazioni. Ci affidiamo all'espressione, che è leggermente diversa da una condizione. In questo caso, inseriamo un valore o un'espressione. Ad esempio, 10 / 2. In questo caso, verrà eseguito il blocco case con la firma case 5 perché l'espressione sopra è uguale a 5.

Possiamo anche utilizzare una condizione qui. In tal caso, è necessario scrivere un'espressione booleana nel blocco dell'espressione, e dovrebbe apparire in questo modo: 10 / 2 == 5. Poi scrivere due case di seguito:

case true:
  
case false:

Tuttavia, questa struttura sarà quasi indistinguibile da un normale if-else.

La parola chiave "break"

Questa parola chiave viene utilizzata per terminare l'esecuzione di un'istruzione switch-case ed uscire dal suo corpo. Questo termine viene spesso utilizzato nei cicli, che verranno trattati nei capitoli successivi. Utilizzare questa parola chiave quando è necessario uscire da un blocco di codice e interrompere la sua esecuzione.

Ora miglioriamo il codice scritto sopra utilizzando l'istruzione switch-case:

Main.java


              123456789101112131415161718192021222324
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // You can change the value of the variable `a` to test the `switch` statement
        int a = 30;
        switch (a) {
            case 10:
                System.out.println(10);
                break;
            case 20:
                System.out.println(20);
                break;
            case 30:
                System.out.println(30);
                break;
            case 40:
                System.out.println(40);
                break;
            default:
                System.out.println("There is no matching value");
        }
    }
}

Possiamo osservare come il codice sia diventato molto più pulito, leggibile e facilmente estendibile. Non è necessario scrivere un'altra istruzione if da zero se occorre aggiungere ulteriori condizioni. È sufficiente aggiungere un nuovo blocco case all'interno della nostra switch-case statement.

Esaminiamo lo schema del blocco switch-case:

Come possiamo vedere, è possibile avere un numero qualsiasi di casi. Ogni caso richiede la propria condizione e il proprio codice, che verrà eseguito quando il programma entra nel blocco del caso. Si consiglia di utilizzare la parola chiave break perché il programma non uscirà dal blocco switch finché tutti i blocchi case non saranno stati eseguiti. Il blocco default verrà eseguito se non si entra in nessun blocco case o non si utilizza la parola chiave break.

Esaminiamo un altro esempio senza le parole chiave break:

Main.java


              1234567891011121314151617181920
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // You can change the value of the variable `a` to test the `switch` statement
        int a = 10;
        switch (a) {
            case 10:
                System.out.println(10);
            case 20:
                System.out.println(20);
            case 30:
                System.out.println(30);
            case 40:
                System.out.println(40);
            default:
                System.out.println("There is no matching value");
        }
    }
}

Abbiamo ricevuto più valori, che differiscono da quelli attesi. Inoltre, abbiamo ottenuto informazioni dai blocchi case 10 e default. Proprio per questo motivo utilizziamo la parola chiave break dopo ogni blocco. In questo modo, il programma uscirà dall'istruzione switch e continuerà la sua esecuzione.