Impara Istruzione Switch-Case | Tipi e Operazioni di Base

Gestione di più condizioni diverse

Quando si devono verificare molte condizioni, l'utilizzo di 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);
		}
    }
}

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.

È anche possibile utilizzare una condizione qui. In tal caso, è necessario scrivere un'espressione booleana nel blocco dell'espressione, che 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");
        }
    }
}

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'interno della nostra switch-case statement.

Esaminiamo lo schema del blocco switch-case:

Come possiamo vedere, è possibile avere tanti case quanti ne desideriamo. Ogni case richiede la propria condizione e il proprio codice, che verrà eseguito quando il programma entra nel blocco case. È 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 se 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 quanto ci aspettavamo. 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.

1. Cosa verrà stampato sulla console?

2. Perché abbiamo bisogno della 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

Scorri per mostrare il menu

Gestione di più condizioni diverse

Quando si devono verificare molte condizioni, l'utilizzo di 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);
		}
    }
}

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é abbiamo bisogno della parola chiave `break`?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 2. Capitolo 6

Istruzione Switch-Case

Gestione di più condizioni diverse

Istruzione switch-case

La parola chiave "break"

1. Cosa verrà stampato sulla console?

2. Perché abbiamo bisogno della parola chiave break?

Istruzione Switch-Case

Gestione di più condizioni diverse

Istruzione switch-case

La parola chiave "break"

1. Cosa verrà stampato sulla console?

2. Perché abbiamo bisogno della parola chiave break?

2. Perché abbiamo bisogno della parola chiave `break`?

2. Perché abbiamo bisogno della parola chiave `break`?