Fallunterscheidung - Versionsgeschichte

Kristin: /* Lösung */

2016-07-26T11:35:17Z

‎Lösung

Kristin am 26. Juli 2016 um 11:34 Uhr

2016-07-26T11:34:50Z

Kristin: /* break */

2016-07-26T11:21:04Z

‎break

Kristin am 19. März 2016 um 22:08 Uhr

2016-03-19T22:08:54Z

Hauer: /* break; */

2016-03-19T00:53:09Z

‎break;

Hauer: /* Verwendung */

2016-03-19T00:52:14Z

‎Verwendung

Hauer am 17. März 2016 um 20:47 Uhr

2016-03-17T20:47:15Z

Kristin am 11. März 2016 um 16:19 Uhr

2016-03-11T16:19:15Z

Kristin am 11. März 2016 um 16:18 Uhr

2016-03-11T16:18:42Z

Marius am 2. Januar 2016 um 15:28 Uhr

2016-01-02T15:28:34Z

@@ Zeile 64: / Zeile 64: @@
 ===Lösung===
-Am Ende jeder Fallbehandlung bzw. vor der Sprungmarke eines nächsten Falles muss eine Anweisung mit dem Schlüsselwort '''break''' verwendet werden, um aus dem Rumpfblock der Fallunterscheidung herauszuspringen.
+Am Ende jeder Fallbehandlung bzw. vor der Sprungmarke eines nächsten Falles muss eine Anweisung mit dem Schlüsselwort '''break''' verwendet werden, um aus dem Rumpfblock der Fallunterscheidung herauszuspringen:
-−
 <source lang="java" title="Fallunterscheidung mit break">

@@ Zeile 1: / Zeile 1: @@
 Eine '''Fallunterscheidung''' ist eine häufig in [[Programmiersprache|Programmiersprachen]] implementierte [[Kontrollstruktur]]. Sie dient dazu,  das Notieren von verschiedenen [[Alternative|bedingten Anweisungen]] zu erleichtern. Dabei springt der Programmfluss vom Kopf der Fallunterscheidung zu einem spezifizierten Fall und setzt von da an die Ausführung fort.
-In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungsblöcken notwendig, mit der <code>break</code>-Anweisung manuell aus der Fallunterscheidung herauszuspringen, wenn man einen Fall abgearbeitet hat.
+In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] '''switch''' für den Kopf der Fallunterscheidung und '''case''' für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und ''keine'' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case'''-Anweisungsblöcken notwendig, mit der '''break'''-Anweisung manuell aus der Fallunterscheidung herauszuspringen, wenn man einen Fall abgearbeitet hat.
 = Syntaxdiagramm =
@@ Zeile 11: / Zeile 11: @@
 = Verwendung =
-Fallunterscheidungen werden verwendet, wenn man mehrere fest definierbare Fälle überprüfen möchte, anstatt eine Verschachtelung von [[Alternative|bedingten Anweisungen]] zu erstellen. Das Wichtigste dabei ist, dass nur Konstanten als Fälle verwendet werden können. Zwei Variablen können also nicht miteinander verglichen werden. Da die eintretbaren Fälle diskret voneinander zu unterscheiden sein müssen, sind nur [[byte]], [[char]], [[short]], [[int]], [[String]] und [[Aufzählungskonstante]]n erlaubt. Man kann also keine Fallunterscheidungen für die Datentypen [[long]], [[float]] und [[double]] verwenden.
+'''Fallunterscheidungen''' werden verwendet, wenn man mehrere fest definierbare Fälle überprüfen möchte, anstatt eine Verschachtelung von [[Alternative|bedingten Anweisungen]] zu erstellen.
 == Kopf ==
-Der Kopf besteht aus dem Schlüsselwort <code>switch</code>, gefolgt von einem in Klammern notierten Term, über den die Fallunterscheidung getroffen werden soll.
+Der '''Kopf''' besteht aus dem Schlüsselwort '''switch''', gefolgt von einem in Klammern notierten Term, über den die Fallunterscheidung getroffen werden soll.
 <source lang="java">
@@ Zeile 25: / Zeile 27: @@
 == Rumpf ==
-Der Rumpf einer Fallunterscheidung wird durch einen [[Block]] eingeleitet. Im Rumpf können die einzelnen Fälle mit einer '''Sprungmarke''' markiert werden. Diese geschieht durch das Schlüsselwort <code>case</code>, gefolgt von einem '''konstanten''' Wert, der für den entsprechenden Fall steht, und einem Doppelpunkt.
+Der '''Rumpf''' einer Fallunterscheidung wird durch einen [[Block]] eingeleitet. Im Rumpf können die einzelnen Fälle mit einer '''Sprungmarke''' markiert werden. Diese geschieht durch das Schlüsselwort '''case''', gefolgt von einem '''konstanten''' Wert, der für den entsprechenden Fall steht, und einem Doppelpunkt.
 <source lang="java">
@@ Zeile 34: / Zeile 36: @@
 </source>
-Zusätzlich kann durch das Schlüsselwort <code>default</code> ein Standardfall deklariert werden, der ausgeführt werden soll, wenn kein anderer Fall passt. Dieser wird entsprechend meistens am Ende der Fallunterscheidung notiert:
+Zusätzlich kann durch das Schlüsselwort '''default''' ein Standardfall deklariert werden, der ausgeführt werden soll, wenn kein anderer Fall passt. Dieser wird entsprechend meistens am Ende der Fallunterscheidung notiert:
 <source lang="java">
@@ Zeile 46: / Zeile 48: @@
 == break ==
-===Erklärung===
+===Problematik===
-Da die einzelnen <code>case</code>- und <code>default</code>-Schlüsselwörter nur Sprungmarken repräsentieren und '''keine Kontrollstruktur''' aufbauen, würde der Programmfluss nach Abarbeiten eines Falls in die nächste Zeile wandern und, ungeachtet der Sprungmarke oder des eingetretenen Falls, weiterarbeiten.
+Da die einzelnen '''case'''- und '''default'''-Schlüsselwörter nur Sprungmarken repräsentieren und '''keine Kontrollstruktur''' aufbauen, würde der Programmfluss nach Abarbeiten eines Falls in die nächste Zeile wandern und, ungeachtet der Sprungmarke oder des eingetretenen Falls, weiterarbeiten:
 <source lang="java" title="Fallunterscheidung ohne break">
 switch(x){
@@ Zeile 59: / Zeile 60: @@
 </source>
-Hier würde also im Fall von ''x ist 1'' der Wert von '''i''' dreimal, im Fall von ''x ist 2'' der Wert von '''i''' zweimal und in allen anderen Fällen der Wert von '''i''' einmal erhöht werden. Dies ist in den meisten Fällen jedoch nicht gewünscht. Daher muss zum Ende jeder Fallbehandlung bzw. vor der Sprungmarke eines nächsten Falles eine Anweisung mit dem Schlüsselwort <code>break</code> verwendet werden, um aus dem Rumpfblock der Fallunterscheidung herauszuspringen.
+Hier würde also im Fall von ''x ist 1'' der Wert von '''i''' dreimal, im Fall von ''x ist 2'' der Wert von '''i''' zweimal und in allen anderen Fällen der Wert von '''i''' einmal erhöht werden. Dies ist in den meisten Fällen jedoch nicht gewünscht.

@@ Zeile 46: / Zeile 46: @@
 == break ==
-Da die einzelnen <code>case</code>- und <code>default</code>-Schlüsselwörter nur Sprungmarken repräsentieren und '''keine Kontrollstruktur''' aufbauen, würde der Programmfluss nach Abarbeiten eines Falls in die nächste Zeile wandern und ungeachtet der Sprungmarke oder des eingetretenen Falls weiterarbeiten.
+===Erklärung===
 ===Beispiele===

@@ Zeile 1: / Zeile 1: @@
 Eine '''Fallunterscheidung''' ist eine häufig in [[Programmiersprache|Programmiersprachen]] implementierte [[Kontrollstruktur]]. Sie dient dazu,  das Notieren von verschiedenen [[Alternative|bedingten Anweisungen]] zu erleichtern. Dabei springt der Programmfluss vom Kopf der Fallunterscheidung zu einem spezifizierten Fall und setzt von da an die Ausführung fort.
-In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungsblöcken notwendig, mit der <code>break</code> Anweisung manuell aus der Fallunterscheidung herauszuspringen, wenn man einen Fall abgearbeitet hat.
+In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungsblöcken notwendig, mit der <code>break</code>-Anweisung manuell aus der Fallunterscheidung herauszuspringen, wenn man einen Fall abgearbeitet hat.
 = Syntaxdiagramm =
@@ Zeile 7: / Zeile 7: @@
 [[Datei:switch_statement.png]]
-(Aktuell noch teilweise Fehlerhaft)
+(Aktuell noch teilweise fehlerhaft)
 = Verwendung =
-Fallunterscheidungen werden verwendet, wenn man mehrere fest definierbare Fälle überprüfen möchte, anstatt eine Verschachtelung von [[bedingten Anweisungen]] zu verwenden. Das wichtigste dabei ist, dass nur Konstanten als Fälle verwendet werden können, man kann also zwei Variablen nicht miteinander vergleichen. Da die eintretbaren Fälle diskret voneinander zu unterscheiden sein müssen, sind nur <code>byte, char, short, int, String</code> und [[Aufzählungskonstante]]n erlaubt. Man kann also keine Fallunterscheidungen für die Datentypen <code>long, float</code> und <code>double</code> verwenden.
+Fallunterscheidungen werden verwendet, wenn man mehrere fest definierbare Fälle überprüfen möchte, anstatt eine Verschachtelung von [[Alternative|bedingten Anweisungen]] zu erstellen. Das Wichtigste dabei ist, dass nur Konstanten als Fälle verwendet werden können. Zwei Variablen können also nicht miteinander verglichen werden. Da die eintretbaren Fälle diskret voneinander zu unterscheiden sein müssen, sind nur [[byte]], [[char]], [[short]], [[int]], [[String]] und [[Aufzählungskonstante]]n erlaubt. Man kann also keine Fallunterscheidungen für die Datentypen [[long]], [[float]] und [[double]] verwenden.
 == Kopf ==
-Der Kopf besteht aus dem Schlüsselwort <code>switch</code> gefolgt von einem zu einem in Klammern notierten Term, über den die Fallunterscheidung getroffen werden soll.
+Der Kopf besteht aus dem Schlüsselwort <code>switch</code>, gefolgt von einem in Klammern notierten Term, über den die Fallunterscheidung getroffen werden soll.
 <source lang="java">
@@ Zeile 25: / Zeile 25: @@
 == Rumpf ==
-Der Rumpf einer Fallunterscheidung wird durch einen [[Block]] eingeleitet. Im Rumpf können die einzelnen Fälle mit einer Sprungmarke markiert werden. Diese wird durch das Schlüsselwort <code>case</code> markiert, gefolgt von einem '''konstanten''' Wert, der für den entsprechenden Fall steht, und einem Doppelpunkt.
+Der Rumpf einer Fallunterscheidung wird durch einen [[Block]] eingeleitet. Im Rumpf können die einzelnen Fälle mit einer '''Sprungmarke''' markiert werden. Diese geschieht durch das Schlüsselwort <code>case</code>, gefolgt von einem '''konstanten''' Wert, der für den entsprechenden Fall steht, und einem Doppelpunkt.
 <source lang="java">
@@ Zeile 44: / Zeile 44: @@
 </source>
-== break; ==
+== break ==
-Da die einzelnen <code>case</code> und <code>default</code> Schlüsselworte nur Sprungmarken repräsentieren und '''keine''' Kontrollstruktur aufbauen, würde nach Abarbeitung eines Falles der Programmfluss in die nächste Zeile wandern und ungeachtet der Sprungmarke oder des eingetretenen Falles weiter arbeiten.
+Da die einzelnen <code>case</code>- und <code>default</code>-Schlüsselwörter nur Sprungmarken repräsentieren und '''keine Kontrollstruktur''' aufbauen, würde der Programmfluss nach Abarbeiten eines Falls in die nächste Zeile wandern und ungeachtet der Sprungmarke oder des eingetretenen Falls weiterarbeiten.
-<source lang="java">
+===Beispiele===
 switch(x){
      case 1: i++;
@@ Zeile 56: / Zeile 57: @@
 </source>
-Hier würde also im Falle von ''x ist 1'' der Wert von '''i''' drei mal erhöht werden, im Falle von ''x ist 2'' der Wert von '''i''' zwei mal erhöht und in allen anderen Fällen der Wert von '''i''' ein mal erhöht werden. Dies ist in den meisten Fällen jedoch nicht gewünscht. Daher muss zum Ende jeder Fallbehandlung bzw. vor der Sprungmarke eines nächsten Falles eine Anweisung mit dem Schlüsselwort <code>break</code> verwendet werden, um aus dem Rumpfblock der Fallunterscheidung heraus zu springen.
+Hier würde also im Fall von ''x ist 1'' der Wert von '''i''' dreimal, im Fall von ''x ist 2'' der Wert von '''i''' zweimal und in allen anderen Fällen der Wert von '''i''' einmal erhöht werden. Dies ist in den meisten Fällen jedoch nicht gewünscht. Daher muss zum Ende jeder Fallbehandlung bzw. vor der Sprungmarke eines nächsten Falles eine Anweisung mit dem Schlüsselwort <code>break</code> verwendet werden, um aus dem Rumpfblock der Fallunterscheidung herauszuspringen.
 <source lang="java">
 switch(wochentag){
      case 1: System.out.println("Montag");
@@ Zeile 77: / Zeile 79: @@
+}
 </source>
 Natürlich kann man sich diese Eigenschaft auch zunutze machen, um mehrere Fälle mit der gleichen Routine zu behandeln:
+<source lang="java" title="Gleiche Ausgabe für mehrere Fälle">
 <source lang="java">
 switch(monat){
      case 1: case 2: case 3: System.out.println("Erstes Quartal");
@@ Zeile 93: / Zeile 96: @@
+}
 </source>
 Hier werden jeweils drei Fälle mit der gleichen Ausgabe behandelt, indem drei Sprungmarken die gleiche Codezeile markieren.
-= Beispiele =
+= Beispiel =
 <source lang="java">
@@ Zeile 112: / Zeile 114: @@
 </source>
-Wenn man davon ausgeht, dass die Variable i den Wert 0 bis zur Fallunterscheidung behält, wird, wenn x den Wert 2 hat, der Wert der Variablen i 2 mal um 1 erhöht, während, wenn sie den Wert 3 oder 4 hat, dies nur ein mal ausgeführt wird. Ist der Wert von x weder 2, 3 oder 4, so erhält i den Wert 10.
+Wenn man davon ausgeht, dass die Variable i den Wert 0 bis zur Fallunterscheidung behält, wird, wenn x den Wert 2 hat, der Wert der Variablen i  zweimal um 1 erhöht, da am Ende der Fallbehandlung case 2 kein '''break''' steht. Wenn sie hingegen den Wert 3 oder 4 hat, wird diese Anweisung jeweils nur einmal ausgeführt. Ist der Wert von x weder 2, 3 noch 4, so erhält i den Wert 10.
 =Verwendete Schlüsselwörter=

@@ Zeile 78: / Zeile 78: @@
 </source>
-Natürlich kann sich dies Eigenschaft auch zunutze gemacht werden, um mehrere Fälle mit der gleichen Routine zu behandeln:
+Natürlich kann man sich diese Eigenschaft auch zunutze machen, um mehrere Fälle mit der gleichen Routine zu behandeln:
 <source lang="java">

← Nächstältere Version		Version vom 11. März 2016, 16:19 Uhr
Zeile 1:		Zeile 1:
−	Eine '''Fallunterscheidung''' ist eine häufig in [[Programmiersprachen]] implementierte [[Kontrollstruktur]]. Sie dient dazu, das Notieren von verschiedenen [[Alternative\|bedingten Anweisungen]] zu erleichtern. Dabei springt der Programmfluss vom Kopf der Fallunterscheidung zu einem spezifizierten Fall und setzt von da an die Ausführung fort.	+	Eine '''Fallunterscheidung''' ist eine häufig in [[Programmiersprache\|Programmiersprachen]] implementierte [[Kontrollstruktur]]. Sie dient dazu, das Notieren von verschiedenen [[Alternative\|bedingten Anweisungen]] zu erleichtern. Dabei springt der Programmfluss vom Kopf der Fallunterscheidung zu einem spezifizierten Fall und setzt von da an die Ausführung fort.

	In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungen notwendig, das Schlüsselwort <code>break;</code> zu verwenden, um aus der Fallunterscheidung herauszuspringen.		In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungen notwendig, das Schlüsselwort <code>break;</code> zu verwenden, um aus der Fallunterscheidung herauszuspringen.

@@ Zeile 1: / Zeile 1: @@
-Eine Fallunterscheidung ist eine häufig in Programmiersprachen implementierte Kontrollstruktur, die einem das Notieren von verschiedenen bedingten Anweisungen erleichtern soll. Dabei springt der Programmfluss vom Kopf der Fallunterscheidung zu einem spezifizierten Fall und setzt von da an die Ausführung fort.
+Eine '''Fallunterscheidung''' ist eine häufig in [[Programmiersprachen]] implementierte [[Kontrollstruktur]]. Sie dient dazu,  das Notieren von verschiedenen [[Alternative|bedingten Anweisungen]] zu erleichtern. Dabei springt der Programmfluss vom Kopf der Fallunterscheidung zu einem spezifizierten Fall und setzt von da an die Ausführung fort.
-In Java wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungen von nöten das Schlüsselwort <code>break;</code> zu verwenden, um aus der Fallunterscheidung herauszuspringen.
+In [[Java]] wird eine Fallunterscheidung durch das [[Schlüsselwort]] <code>switch</code> für den Kopf der Fallunterscheidung und <code>case</code> für die einzelnen Fälle deklariert. Da ein Fall nur eine Sprungmarke für den Programmfluss ist und '''keine''' sonstige Programmflusskontrolle vorgenommen wird, ist es speziell in diesen sogenannten '''switch-case''' Anweisungen notwendig, das Schlüsselwort <code>break;</code> zu verwenden, um aus der Fallunterscheidung herauszuspringen.
 = Syntaxdiagramm =
@@ Zeile 17: / Zeile 17: @@
-=verwendete Schlüsselwörter=
+=Verwendete Schlüsselwörter=
 *switch
 *case
 *break