Deklarieren und Initialisieren von Variablen in Java-Switches

Ich habe eine verrückte Frage zu Java-Switches.

int key = 2;

switch (key) {
    case 1:
        int value = 1;
        break;
    case 2:
        value = 2;
        System.out.println(value);
        break;
    default:
        break;
}

Szenario 1 - Wenn die keybeiden ist es erfolgreich den Wert als 2. drucken
Szenario 2 - Wenn ich Kommentar werde value = 2in case 2:es die kreischt sagen Die lokale Variable Wert nicht initialisiert worden sein .

Fragen:

Szenario 1: Wenn der Ausführungsfluss nicht zu case 1:(wann key = 2) wechselt, woher kennt er dann den Typ der Wertvariablen als int?

Szenario 2: Wenn der Compiler den Typ der Wertvariablen als kennt int, muss er auf den int value = 1;Ausdruck in zugegriffen haben case 1:(Deklaration und Initialisierung). Warum tut es sqawrk Wenn ich werde Kommentar value = 2in case 2:die sagen , die lokale Variable Wert kann nicht initialisiert wurden .

Switch-Anweisungen sind im Hinblick auf den Umfang grundsätzlich ungerade. Aus Abschnitt 6.3 des JLS :

Der Umfang einer lokalen Variablendeklaration in einem Block (§14.4) ist der Rest des Blocks, in dem die Deklaration angezeigt wird, beginnend mit einem eigenen Initialisierer und einschließlich aller weiteren Deklaratoren rechts in der lokalen Variablendeklarationsanweisung.

In Ihrem Fall case 2befindet es sich im selben Block wie case 1und wird danach angezeigt, obwohl case 1es niemals ausgeführt wird. Die lokale Variable befindet sich also im Gültigkeitsbereich und kann geschrieben werden, obwohl Sie die Deklaration logischerweise nie "ausführen". (Eine Deklaration ist nicht wirklich "ausführbar", obwohl die Initialisierung erfolgt.)

Wenn Sie die value = 2;Zuweisung auskommentieren, weiß der Compiler immer noch, auf welche Variable Sie sich beziehen, aber Sie haben keinen Ausführungspfad durchlaufen, der ihr einen Wert zuweist. Aus diesem Grund erhalten Sie wie beim Versuch einen Fehler Lesen Sie jede andere nicht definitiv zugewiesene lokale Variable.

Ich würde Ihnen dringend empfehlen, keine in anderen Fällen deklarierten lokalen Variablen zu verwenden - dies führt, wie Sie gesehen haben, zu höchst verwirrendem Code. Wenn ich lokale Variablen in switch-Anweisungen einführe (was ich selten versuche - Fälle sollten im Idealfall sehr kurz sein), bevorzuge ich normalerweise die Einführung eines neuen Bereichs:

case 1: {
    int value = 1;
    ...
    break;
}
case 2: {
    int value = 2;
    ...
    break;
}

Ich glaube das ist klarer.

Die Variable wurde deklariert (als int), aber nicht initialisiert (mit einem Anfangswert versehen). Denken Sie an die Linie:

int value = 1;

Wie:

int value;
value = 1;

Der int valueTeil teilt dem Compiler zur Kompilierungszeit mit, dass Sie eine Variable namens value haben, die ein int ist. Der value = 1Teil initialisiert es, aber das passiert zur Laufzeit und überhaupt nicht, wenn dieser Zweig des Schalters nicht eingegeben wird.

Von http://www.coderanch.com/t/447381/java-programmer-SCJP/certification/variable-initialization-within-case-block

Deklarationen werden zur Kompilierungszeit verarbeitet und hängen nicht vom Ausführungsfluss Ihres Codes ab. Da valuees im lokalen Bereich des Switch-Blocks deklariert ist, kann es ab dem Zeitpunkt seiner Deklaration an einer beliebigen Stelle in diesem Block verwendet werden.

Mit der Integration von JEP 325: Switch Expressions (Vorschau) in JDK-12-Builds für den frühen Zugriff. Es gibt bestimmte Änderungen, die aus Jons Antwort ersichtlich sind -

1. Umfang lokaler Variablen - Die lokalen Variablen in den Switch-Fällen können jetzt lokal für den Fall selbst anstatt für den gesamten Switch-Block sein . Ein Beispiel (ähnlich wie Jon es auch syntaktisch versucht hatte) unter Berücksichtigung derDayEnum-Klasse zur weiteren Erklärung:

   public enum Day {
       MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
   }
   
   // some another method implementation
   Day day = Day.valueOf(scanner.next());
   switch (day) {
       case MONDAY,TUESDAY -> {
           var temp = "mon-tue";
           System.out.println(temp);
       }
       case WEDNESDAY,THURSDAY -> {
           var temp = Date.from(Instant.now()); // same variable name 'temp'
           System.out.println(temp);
       }
       default ->{
           var temp = 0.04; // different types as well (not mandatory ofcourse)
           System.out.println(temp);
       }
   }

2. Switch-Ausdrücke - Wenn die Absicht besteht, einer Variablen einen Wert zuzuweisen und ihn dann zu verwenden, können die Switch-Ausdrücke einmal verwendet werden. z.B

   private static void useSwitchExpression() {
       int key = 2;
       int value = switch (key) {
           case 1 ->  1;
           case 2 -> 2;
           default -> {break 0;}
       };
       System.out.println("value = " + value); // prints 'value = 2'
   }

Diese Erklärung könnte helfen.

    int id=1;

    switch(id){
        default: 
            boolean b= false; // all switch scope going down, because there is no scope tag

        case 1:
            b = false;
        case 2:{
            //String b= "test"; you can't declare scope here. because it's in the scope @top
            b=true; // b is still accessible
        }
        case 3:{
            boolean c= true; // case c scope only
            b=true; // case 3 scope is whole switch
        }
        case 4:{
            boolean c= false; // case 4 scope only
        }
    }

Java-Spezifikation:

https://docs.oracle.com/javase/specs/jls/se12/html/jls-14.html#jls-14.11

Der Fall eines plötzlichen Abschlusses aufgrund eines Bruches mit einem Etikett wird durch die allgemeine Regel für beschriftete Anweisungen (§14.7) behandelt.

https://docs.oracle.com/javase/specs/jls/se12/html/jls-14.html#jls-14.7

Beschriftete Aussagen:

LabeledStatement: Bezeichner: Anweisung

LabeledStatementNoShortIf: Bezeichner: StatementNoShortIf

Im Gegensatz zu C und C ++ hat die Programmiersprache Java keine goto-Anweisung. Bezeichner-Anweisungsbezeichnungen werden mit break-Anweisungen (§14.15) oder continue-Anweisungen (§14.16) verwendet, die an einer beliebigen Stelle in der beschrifteten Anweisung erscheinen.

Der Geltungsbereich einer Kennzeichnung einer gekennzeichneten Anweisung ist die unmittelbar enthaltene Anweisung.

Mit anderen Worten, Fall 1, Fall 2 sind Bezeichnungen innerhalb der switch-Anweisung. break and continue-Anweisungen können auf Beschriftungen angewendet werden.

Da Beschriftungen den Gültigkeitsbereich der Anweisung gemeinsam nutzen, teilen sich alle in Beschriftungen definierten Variablen den Gültigkeitsbereich der switch-Anweisung.