Welche Zeilen compilieren nicht einwandfrei?
final int AbtNr;
Byte PersSchlüssel=7;
Integer PersNr=123;
AbtNr=10;
switch(PersSchlüssel){
case 128:System.out.println(“128″);//1
default:System.out.println(“default”);//2
case AbtNr:System.out.println(“AbtNr”);//3
case PersNr:PersNr++ ;//4
| Antwort/ answer | |
|---|---|
Was ist die Ausgabe bei folgendem Code?
long a = 10;
switch(a){
default:
System.out.println(“1″);
case 1:
System.out.println(“2″);
case 10:
System.out.println(“3″);
case 5:
System.out.println(“4″);
}
| Antwort/ answer | |
|---|---|
Um zu verdeutlichen, was Labels sind, erst einmal ein Beispiel einer nicht mit label versehenen Schleife:
for (int a = 0; a<3; a++){
for (int b =0; b<4; b++){
if (b ==3)
break;
System.out.println(“a: “+a+” b: “+b);
}
}
Hier geschieht nichts unerwartetes, die Ausgabe ist
a: 0 b: 0
a: 0 b: 1
a: 0 b: 2
a: 1 b: 0
a: 1 b: 1
a: 1 b: 2
a: 2 b: 0
a: 2 b: 1
a: 2 b: 2
Nun die Abänderung mit Label, die bewirkt, das break nicht auf der Ebene der letzten Schleife, sondern auf einer definierten Ebene zieht:
aussen: // Label, kann beliebig benannt werden
f or (int a = 0; a<3; a++){
for (int b =0; b<4; b++){
if (b ==3)
break aussen; // Hinweis, das break an dem Label “aussen” wirken soll
System.out.println(“a: “+a+” b: “+b);
}
}
Die Schleife wird also nicht innerhalb der Schleife, sondern am Punkt aussen beendet; die Ausgabe ist demnach:
a: 0 b: 0
a: 0 b: 1
a: 0 b: 2
Labels können nicht außerhalb der Anweisung, in der sie definiert wurden aufgerufen werden. Sie könnnen im übrigen auf gleicher Art und Weise bei continue angewandt werden.
Für Arrays gibt es zusätzlich eine veränderte/ erweiterte Form der for-Schleife; statt
for (int b=0; b<a.length; b++)
System.out.println(a[b]);
hat
for (int b : a)
System.out.println(b);
den gleichen Effekt.
Es gibt noch ein paar Kleinigkeiten, die ich erwähnen möchte, bevor wir das Kapitel “For-Schleifen” abschließen können;
Die Bedingung kann absolut unabhängig von der Intitialisierung sein:
for (int a=0; b <12 ; a++){
b++;
}
kompiliert daher fehlerfrei.
Das die Iteration weggelassen werden kann, haben ich ja schon erläutert. Sie kann aber auch durch etwas anderes ersetzt werden:
for (int a=0; b <12 ; System.out.println(“Hallo”)){
b++;
}
Die Ausgabe ist
Test
Test
Wir haben ja schon besprochen, dass eine for-Schleife folgendermaßen aufgebaut ist:
for (<Initialisierung>;<Bedingung>;<Iteration>) { Schleifen-Inhalt }
Dies bedeutet aber nicht, dass jeder einzelne Bereich gefüllt werden muss.
for ( ; ; ) { … }
ist also eine valide Deklaration, auch wenn diese ohne Bedingung und Iteration eine Endlosschleife darstellt. Mit break kann diese Endlossschleife beendet werden:
int i=0;
for ( ; ; ){
if (i++==10)
break;
}
Häufiger als dies werden leere Teilbereiche innerhalb der For-Schleife benutzt:
int i = 10;
for ( ;i<5;i–){ … }
Mit System.exit(0) innerhalb einer for-Schleife wird das Programm sofort abgebrochen, eine Weiterführung der bestehenden Schleifen, des Unterprogrammes oder des Hauptprogrammes findet nicht statt.
class Angestellter {
public static void main(String args[]) {
System.out.println(“Start im Hauptprogramm: “);
Buchhalter.forSchleife(); // Aufruf der statischen Methode “forSchleife()” von Buchhalter.
System.out.println( “Ende des Hauptprogrammes”);// Hauptprogramm wird bei System.exit(0) nicht weiter ausgeführt
}
}
class Buchhalter extends Angestellter {
public static void forSchleife() {
System.out.println(“Start Unterprogramm: “);
for (int b=0; b<3; b++) { // Schleife 1
for (int a=0; a < 10; ++a){ // Schleife 2
System.out.print(“\na: “+a);
if (a==2)
System.exit(0); // System-Ausstieg
}
System.out.print(” b: ” +b); // Schleife 1 kann bei Programmende nicht weiter ausgeführt werden
}
System.out.println(“\nEnde Unterprogramm”); // Da das Programm bei einem Wert a==2 beendetwird, wird diese Stelle nie erreicht.
}
}
Die Ausgabe ist demnach
Start im Hauptprogramm:
Start Unterprogramm:
a: 0
a: 1
a: 2
Mit return innerhalb einer for-Schleife wird sofort ins Hauptprogramm zurückgekehrt, eine Weiterführung der bestehenden Schleifen oder des Unterprogrammes generell findet nicht statt.
class Angestellter {
public static void main(String args[]) {
System.out.println(“Start im Hauptprogramm: “);
Buchhalter.forSchleife(); // Aufruf der statischen Methode “forSchleife()” von Buchhalter.
System.out.println( “Ende des Hauptprogrammes”);
}
}
class Buchhalter extends Angestellter {
public static void forSchleife() {
System.out.println(“Start Unterprogramm: “);
for (int b=0; b<3; b++) { // Schleife 1
for (int a=0; a < 10; ++a){ // Schleife 2
System.out.print(“\na: “+a);
if (a==2)
return; // Verlassen des Unterprogrammes, wenn a den Wert von 2 erreicht
}
System.out.print(” b: ” +b); // Schleife 1 wird bei return nicht weitergeführt
}
System.out.println(“\nEnde Unterprogramm”); // Da das Unterpgrogramm bei einem Wert a==2 verlassen wird, wird diese Stelle nie erreicht.
}
}
Die Ausgabe ist demnach
Start im Hauptprogramm:
Start Unterprogramm:
a: 0
a: 1
a: 2Ende des Hauptprogrammes
Mit break springt man aus der aktuellen Schleife, alles arbeitet wie spezifiziert weiter:
class Angestellter {
public static void main(String args[]) {
System.out.println(“Start im Hauptprogramm: “);
Buchhalter.forSchleife(); // Aufruf der statischen Methode “forSchleife()” von Buchhalter.
System.out.println( ”Ende des Hauptprogrammes”);
}
}
class Buchhalter extends Angestellter {
public static void forSchleife() {
System.out.println(“Start Unterprogramm: “);
for (int b=0; b<3; b++) { // Schleife 1
for (int a=0; a < 10; ++a){ // Schleife 2
System.out.print(“\na: “+a);
if (a==2)
break; // Abbruch von Schleife 2 wenn a den Wert 2 erreicht
} // Wenn “break” greift, wird auch a nicht mehr (wie üblich) hochgezählt
System.out.print(” b: ” +b); // Die erste Schleife wird weitergeführt
}
System.out.println(“\nEnde Unterprogramm”);
}
}
Die Ausgabe ist demnach:
Start im Hauptprogramm:
Start Unterprogramm:
a: 0
a: 1
a: 2 b: 0
a: 0
a: 1
a: 2 b: 1
a: 0
a: 1
a: 2 b: 2
Ende Unterprogramm
Ende des Hauptprogrammes
Bei der Iteration innerhalb einer For-Schleife bitte beachten, dass sich der Wert erst ändert, wenn der Schleifen-Inhalt abgearbeitet wird:
for (int a=0; a < 1; a++){
System.out.println(a); // Ausgabe: 0
} // erst hier wird a um 1 hochgezählt
Die Ausgabe ändert sich auch nicht bei einer Vor-Inkrementierung:
for (int a=0; a < 1; ++a){
System.out.println(a); // Ausgabe ist ebenfalls 0
} // Auch hier wird ebenfalls erst um 1 hochgezählt
Auch sind mehrere Iterationen möglich, die durch Komma getrennt werden:
for (int a=0, b=0; a < 1; a++, b++){ … }
