Impara Istruzione Switch-Case | Tipi di Base e Operazioni

Gestione di più condizioni differenti

Quando si devono verificare molte condizioni, l'utilizzo di catene di if-else può risultare poco pratico.

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);
		}
    }
}

Si può 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ò osservare l'utilizzo dei blocchi switch per eseguire selettivamente delle operazioni. Si fa affidamento sull'espressione, che è leggermente diversa da una condizione. In questo caso, si inserisce 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.

È possibile utilizzare anche una condizione. In tal caso, è necessario scrivere un'espressione booleana nel blocco dell'espressione, che dovrebbe apparire in questo modo: 10 / 2 == 5. Successivamente, scrivere due case:

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 è 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");
        }
    }
}

Si può notare come il codice sia diventato molto più pulito e facile da leggere ed estendere. Non è necessario scrivere un'altra istruzione if da zero se occorre aggiungere ulteriori condizioni. Invece, è possibile aggiungere un altro blocco case all'istruzione switch-case statement.

Esaminiamo lo schema del blocco switch-case:

Come possiamo vedere, è possibile avere quanti casi desideriamo. Ogni caso richiede la propria condizione e il proprio codice, che verrà eseguito quando il programma entra nel blocco del caso. È consigliabile 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.

Vediamo 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 si utilizza la parola chiave break dopo ogni blocco. In questo modo, il programma uscirà dall'istruzione switch e continuerà la sua esecuzione.

1. Cosa verrà stampato sulla console?

2. Perché è necessaria la parola chiave `break`?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 6

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain the difference between the classic and new switch syntax in Java?

What happens if I forget to use the break statement in a switch-case?

Can you give more examples of when to use switch-case instead of if-else?

Scorri per mostrare il menu

Gestione di più condizioni differenti

Quando si devono verificare molte condizioni, l'utilizzo di catene di if-else può risultare poco pratico.

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);
		}
    }
}

Si può 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
}

case true:
  
case false:

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

La parola chiave "break"

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");
        }
    }
}

Esaminiamo lo schema del blocco switch-case:

Vediamo 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");
        }
    }
}

1. Cosa verrà stampato sulla console?

2. Perché è necessaria la parola chiave `break`?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 6

Istruzione Switch-Case

Gestione di più condizioni differenti

Istruzione switch-case

La parola chiave "break"

1. Cosa verrà stampato sulla console?

2. Perché è necessaria la parola chiave break?

Istruzione Switch-Case

Gestione di più condizioni differenti

Istruzione switch-case

La parola chiave "break"

1. Cosa verrà stampato sulla console?

2. Perché è necessaria la parola chiave break?

2. Perché è necessaria la parola chiave `break`?

2. Perché è necessaria la parola chiave `break`?