Lära Switch-Case-Sats | Grundläggande Typer och Operationer

Hantering av flera olika villkor

När vi har många villkor att kontrollera kan användning av flera if-else kedjor vara opraktiskt.

Till exempel:

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

Vi kan se att detta inte ser rent och professionellt ut. För sådana fall tillhandahåller Java satsen switch-case.

switch-case-sats

switch-case-satsen består av flera delar:

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
}

I koden ovan kan du se att vi använder switch-block för att selektivt utföra operationer. Vi förlitar oss på uttrycket, vilket skiljer sig något från ett villkor. Där anger vi ett värde eller ett uttryck. Till exempel, 10 / 2. I detta fall kommer case-blocket med signaturen case 5 att köras eftersom uttrycket ovan är lika med 5.

Vi kan också använda ett villkor här. I så fall behöver vi skriva ett Booleskt uttryck i uttrycksblocket, och det bör se ut ungefär så här: 10 / 2 == 5. Skriv sedan två case nedan:

case true:
  
case false:

Men denna struktur kommer nästan inte att skilja sig från en vanlig if-else.

Nyckelordet "break"

Vi använder detta nyckelord för att avsluta exekveringen av ett switch-case-uttryck och lämna dess block. Detta ord används ofta i loopar, vilket vi kommer att diskutera i följande kapitel. Använd detta nyckelord när du behöver avbryta ett kodblock och stoppa dess exekvering.

Nu ska vi förbättra koden vi skrev ovan genom att använda satsen 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");
        }
    }
}

Vi kan se hur koden har blivit mycket renare och enklare att läsa samt utöka. Det är inte nödvändigt att skriva ett nytt if-uttryck från början om vi behöver lägga till ytterligare villkor. Istället kan vi lägga till ett nytt case-block i vår switch-case statement.

Låt oss titta på schemat för switch-case-blocket:

Som vi kan se kan det finnas så många case som vi önskar. Varje case kräver ett eget villkor och kod, som kommer att köras när vårt program går in i case-blocket. Det är rekommenderat att använda nyckelordet break eftersom programmet inte lämnar switch-blocket förrän alla case-block har körts. Default-blocket kommer att köras om vi inte går in i något av våra case-block eller inte använder break-nyckelordet.

Låt oss titta på ett annat exempel utan break-nyckelord:

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

Vi har fått flera värden som skiljer sig från vad vi förväntade oss. Dessutom fick vi information från blocken case 10 och default. Det är just därför vi använder nyckelordet break efter varje block. På så sätt avslutar programmet switch-satsen och fortsätter sin exekvering.

1. Vad kommer att skrivas ut i konsolen?

2. Varför behöver vi nyckelordet `break`?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 6

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Svep för att visa menyn

Hantering av flera olika villkor

När vi har många villkor att kontrollera kan användning av flera if-else kedjor vara opraktiskt.

Till exempel:

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

Vi kan se att detta inte ser rent och professionellt ut. För sådana fall tillhandahåller Java satsen switch-case.

switch-case-sats

switch-case-satsen består av flera delar:

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
}

Vi kan också använda ett villkor här. I så fall behöver vi skriva ett Booleskt uttryck i uttrycksblocket, och det bör se ut ungefär så här: 10 / 2 == 5. Skriv sedan två case nedan:

case true:
  
case false:

Men denna struktur kommer nästan inte att skilja sig från en vanlig if-else.

Nyckelordet "break"

Nu ska vi förbättra koden vi skrev ovan genom att använda satsen 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");
        }
    }
}

Låt oss titta på schemat för switch-case-blocket:

Låt oss titta på ett annat exempel utan break-nyckelord:

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. Vad kommer att skrivas ut i konsolen?

2. Varför behöver vi nyckelordet `break`?

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 2. Kapitel 6

Switch-Case-Sats

Hantering av flera olika villkor

switch-case-sats

Nyckelordet "break"

1. Vad kommer att skrivas ut i konsolen?

2. Varför behöver vi nyckelordet break?

Switch-Case-Sats

Hantering av flera olika villkor

switch-case-sats

Nyckelordet "break"

1. Vad kommer att skrivas ut i konsolen?

2. Varför behöver vi nyckelordet break?

2. Varför behöver vi nyckelordet `break`?

2. Varför behöver vi nyckelordet `break`?