3. Grundanweisungen in Java

3. Grundanweisungen in Java Die Grundanweisungen entsprechen den Prinzipien der strukturierten Programmierung 1. Zuweisung 2. Verzweigungen 3. Wiederholungen 4. Anweisungsfolge (Sequenz) Die Anweisungen einer Folge werden der Reihe nach ausgeführt Anweisungen werden durch ; abgeschlossen Es gibt spezielle Anweisungen, wie z.b. Die new Anweisung erzeugt neue Objekte Die try Anweisung erleichtert die Fehlerbehandlung László Böszörményi ESOP Anweisungen - 1

Zuweisung Grundform: Variable = Ausdruck 1. Die linke Seite (die Adresse der Variable ) wird berechnet 2. Der Ausdruck auf der rechten Seite wird ausgewertet 3. Dieser Wert wird der im 1. berechneten Adresse zugewiesen (Damit geht der ursprüngliche Wert der linken Seite verloren) Typanpassung, Umwandlung der rechten Seite möglich int i = 100; // Initialisierung: auch eine Zuweisung, float f = 200.5f; // die vor der ersten Anweisung eines double d = 300.6; // Blocks (siehe später) ausgeführt wird d = f; // Implizite Anpassung, kein Verlust f = i; // Implizite Anpassung, kein Verlust i = (int) f; // Explizite Umwandlung, Verlust möglich f = (float) d; // Explizite Umwandlung, Verlust möglich (int) f = i; // Unerlaubt! László Böszörményi ESOP Anweisungen - 2

Zuweisung als Ausdruck Eine Zuweisung kann selber als Ausdruck (auf der rechten Seite) verwendet werden Bei mehreren Zuweisungen ohne Klammerung, werden sie von rechts bearbeitet int a, b, c, d = 100; // a, b, c noch unbestimmt! a = b = c = d; // a = (b = (c = d))), alle == 100 a = b = c + d; // a, b == 200, c, d == 100 a = 3 * (b = c + d) + 4; // a == 604, b == 200, c,d==100 László Böszörményi ESOP Anweisungen - 3

Form: Zuweisungen mit Selbstbezug Variable Operator "=" Ausdruck Semantik: Variable_X = Variable_X Operator (Ausdruck) int x = 100, y = 200, z = 300, w = 400; x += 10; // x = x + 10: x == 110 y -= 50; // y = y 50: y == 150 z *= 3; // z = z * 3: z == 900 w /= 4; // w = w / 4: w == 100 Achtung auf die Reihenfolge der Auswertung! x *= 5 + 2; x = x * (5 + 2) für x == 10 ergibt 70 x *= 5 + 2; x = x * 5 + 2; für x == 10 ergibt 52 László Böszörményi ESOP Anweisungen - 4

Kompakte Operatoren Erhöhen bzw. Erniedrigen: ++, -- Können als eigene Anweisung stehen x ++; x += 1; x = x + 1; x --; x -= 1; x = x - 1; Können als Teil eines Ausdrucks stehen Können vor- bzw. nachgestellt sein: Viel zu komplex! Erhöhung (Erniedrigung) vor bzw. nach der Verwendung Kompakt, kann aber sehr unübersichtlich werden! Verständlichkeit geht Kompaktheit vor! x = 100; y = 200; z = 300; x*= y * z++ + --x; // x == 6009900, y == 200, z == 301 // x = x * ( (y * z) + (x - 1) ); z++; László Böszörményi ESOP Anweisungen - 5

Block Allgemeine Form eines Blocks ( Anweisungsklammerung ): { Deklarationen Anweisungsfolge } Anweisungen (nicht als Ausdruck verwendet) können immer durch einen Block ersetzt werden Blöcke können beliebig geschachtelt werden Namen sind ab ihrer Deklaration bis Ende des Blocks der Deklaration gültig (siehe auch später) static void main(string [] args) { int x = 1, y = x; // x schon bekannt für y { int z = y + 1; // z == 2 x = z; // Seiteneffekt } // Ende des eingeschachtelten Blocks Out.println("x, y = " + x + ", " + y); } // main x, y = 2, 1 Gültigkeitsbereich von x und y Gültigkeitsbereich von z (x, y sind auch gültig) z ist hier unbekannt László Böszörményi ESOP Anweisungen - 6

Alternative (If-Anweisung) Allgemeine Form if (b) Anweisung 1 else Anweisung 2 Ausführung 1. Die Bedingung b (Boolescher Ausdruck) wird ausgewertet 2. Ist b wahr, Anweisung 1 (then-zweig) wird ausgeführt 3. Ist b falsch, und Es gibt den else-zweig: Anweisung 2 wird ausgeführt Es gibt keinen else-zweig: Die nächste Anweisung wird ausgeführt (if bleibt wirkungslos falls die Auswertung von b frei von Seiteneffekten ist) if (x < y) min = x; else min = y; // Berechnet das Minimum zweier Zahlen if (x < y) { min = x; } else { min = y; } //Anweisungen durch Block ersetzt László Böszörményi ESOP Anweisungen - 7

Einfache If-Anweisungen static void main(string [] args) { int x ; String s = ""; // s initialisiert mit dem leeren String Out.println("Teilbarkeit von x durch 2,3,4,5\nBitte x eingeben"); x = In.readInt(); if (x % 2 == 0) s += " 2"; if (x % 3 == 0) s += " 3"; if (x % 4 == 0) s += " 4"; if (x % 5 == 0) s += " 5"; // Einzelanweisung im then-zweig if (s.equals("")) s = " keine der gegebenen Zahlen"; Out.println(x + " ist teilbar durch" + s); } // main x = 60 : 60 ist teilbar durch 2 3 4 5 x = 7 : 7 ist teilbar durch keine der gegebenen Zahlen László Böszörményi ESOP Anweisungen - 8

If-Anweisungen, Einzelanweisung als Block if (x % 2 == 0) { s += " 2"; } // Einzelanweisung als Block if (x % 3 == 0) { // Einzelanweisung als Block + s += " 3"; } // if (x % 3 == 0) // Strukturierte Formatierung Die Verwendung von Blöcken erleichtert die Übersicht Die Struktur ist leichter ersichtlich Weitere Anweisungen sind leicht einzufügen Spätere Erweiterungen sind auch leichter Anweisungen und Deklarationen können in die schon bestehenden Blöcke eingefügt werden die Struktur bleibt Es wird generell empfohlen Blöcke zu verwenden und die Strukturen mit Einrückung zu visualisieren In der Vorlesung aus Platzgründen nicht immer eingehalten László Böszörményi ESOP Anweisungen - 9

Häufiger Fehler durch vergessene Blöcke static void main(string [] args) { Out.print("x = "); double x = In.readDouble(); if (x <= 0) else Out.println(x + " ist negativ oder 0"); Out.println(x + " ist positiv"); double y = Math.sqrt(x); // Liest eine Zahl // Wenn nicht positiv: // Wenn positiv: // auch Quadratwurzel else- Zweig Out.println("Quadratwurzel von " + x + "= " + y); Nach } // main dem if Wir wollen die Quadratwurzel nur für positive Zahlen berechnen Obiges Programm versucht sie aber auch für negative Zahlen zu berechnen: es fehlt die Block-Klammerung László Böszörményi ESOP Anweisungen - 10

Geschachtelte if-anweisungen static void main(string [] args) { // Testet Größenordnung von x int x ; String s; Out.println("Bitte x eingeben"); x = In.readInt(); if (x >= 0) if (x < 10) s = "einstellig"; else if (x < 100) s = "zweistellig"; else if (x < 1000) s = "dreistellig"; else s = "mindestens vierstellig"; else s = "negativ"; Out.println(x + " ist " + s); x = 100 : 100 ist dreistellig } // main Darstellung der Struktur durch Einrückung verbesserbar: Direkt unterstützt durch viele Editoren László Böszörményi ESOP Anweisungen - 11

if (x >= 0) { // then-zweig von if (x >= 0) if (x < 10) { // then-zweig von if (x < 10) s = "einstellig"; } // Ende then-zweig von if (x < 10) else { // else-zweig von if (x < 10) if (x < 100) { // then-zweig von if (x < 100) s = "zweistellig"; } // Ende then-zweig von if (x < 100) else { // else-zweig von if (x < 100) if (x < 1000) { // then-zweig von if (x < 1000) s = "dreistellig"; } // Ende then-zweig von if (x < 1000) else { // else-zweig von if (x < 1000) s = "mindestens vierstellig"; } // Ende else-zweig von if (x < 1000) } // Ende else-zweig von if (x < 100) } // Ende else-zweig von if (x < 10) } // Ende then-zweig von if (x >= 0) else { // else-zweig von if (x >= 0) s = "negativ"; } // Ende else-zweig von if (x >= 0) László Böszörményi ESOP Anweisungen - 12

Empfindsamkeit von if auf die Reihenfolge static void main(string [] args) { // Testet Größenordnung von x int x ; String s; Out.println("Bitte x eingeben"); x = In.readInt(); if (x >= 0) if (x < 10) s = "einstellig"; else if (x < 1000) s = "dreistellig"; else if(x < 100) s = "zweistellig"; else s = "mindestens vierstellig"; else s = "negativ";! Out.println (x + " ist " + s); } // main Für x = 10 : 10 ist dreistellig ist natürlich falsch! László Böszörményi ESOP Anweisungen - 13

Disjunkte Bedingungen static void main(string [] args) { // Testet Größenordnung von x int x ; String s; Out.println("Bitte x eingeben"); x = In.readInt(); if (x >= 0) if (x >= 0 && x < 10) s = "einstellig"; Reihenelse if (x >= 100 && x < 1000) s = " dreistellig"; folge else if (x >= 10 && x < 100) s = "zweistellig"; egal else s = "mindestens vierstellig"; else s = "negativ"; Out.println(x + " ist " + s); } // main Für x = 10: 10 ist zweistellig Reihenfolge ist irrelevant László Böszörményi ESOP Anweisungen - 14

Wiederholung (Schleifen) Erhöht massiv die Mächtigkeit der Programmierung Anweisungsfolgen beliebig oft wiederholt Schleifen bestehen aus Schleifenkörper und Abbruchbedingung Es ist die Verantwortung des Programmierers, dass die Schleife terminiert Die Varianten unterscheiden sich in diesen Punkten 1. Zuerst Abbruchbedingung abfragen, dann Schleifenkörper ausführen (while) 2. Zuerst Schleifenkörper ausführen dann Abbruchbedingung abfragen (do-while) 3. Geschlossene Schleife Vorbereitung und Fortschaltung ist Teil der Schleifenkonstruktion (for) Bei den while-schleifen: keine eingebaute Fortschaltung Die for-schleife unterstützt Korrektheit etwas besser László Böszörményi ESOP Anweisungen - 15

While-Schleife Allgemeine Form while (Bedingung) Schleifenkörper Ausführung 1. Die Bedingung (logischer Ausdruck) wird ausgewertet 2. Ist sie wahr 1. Der Schleifenkörper (Anweisungsfolge) wird ausgeführt 2. Nach der Ausführung geht es wieder von 1. weiter 3. Ist die Bedingung falsch: Nächste Anweisung wird ausgeführt Ganzzahlige Division positiver Zahlen mit nur + und int dividend = In.readInt(), divisor = In.readInt(), result = 0; while (dividend >= divisor) { // Solange Dividend nicht kleiner als Divisor result++; // result = result + 1 dividend -= divisor; // dividend = dividend - divisor } // while László Böszörményi ESOP Anweisungen - 16

Bearbeitung einer Zahlenreihe static void main(string [] args) { // Arithmetisches Mittel positiver Zahlen int x, sum = 0, n = 0; float middle; Out.println("Geben Sie eine Reihe positiver Zahlen ein, die mit 0 endet"); x = In.readInt(); while (x > 0) { // Solange x größer 0 sum += x; // sum = sum + x n++; // n = n + 1 x = In.readInt(); // nächste Zahl von der Eingabe } // while if (n > 0) { // Zumindest eine Zahl 0 wurde eingegeben middle = (float) sum / n; /* middle = sum/ n; würde den Bruchteil verschlucken */ Out.println("Arithmetisches Mittel = " + middle); } else // Die erste Zahl war 0 Out.println("Leere Eingabe"); } // main Für 1 7 9 0: Arithmetisches Mittel = 5.6666665 László Böszörményi ESOP Anweisungen - 17

Euklid-Algorithmus mit Eingabekontrolle static int ReadPosInt() { // Liest eine positive Zahl Out.print("Geben Sie bitte eine positive Zahl ein = "); int x = In.readInt(); while (x <= 0) { // Solange x nicht positiv ist Out.print("Geben Sie bitte eine positive Zahl ein = "); x = In.readInt(); // Die Eingabe wird wiederholt, sonst wäre das } // eine unendliche Schleife! return x; } // ReadPosInt; static void main(string [] args) { // Der Euklid Algorithmus funktioniert Out.println("Euklid Algorithmus"); // nur für positive Zahlen int a = ReadPosInt(), b = ReadPosInt(); // a und b sind garantiert positiv while (a!= b) if (a > b) a = a - b; else b = b - a; Out.println("Groesster gemeinsamer Teiler = " + a); } // main László Böszörményi ESOP Anweisungen - 18

Schleifeninvarianten Ergebnis (Q) mit Hilfe der Aussagenlogik Schleifeninvariante (I) gilt während der ganzen Ausfürung {I} while (Bedingung) Anweisung {I}; Abbruchbedingung (B): B I Q Partielle Korrektheit Wir zeigen, dass B I Q Totale Korrektheit Wir zeigen auch, dass der Algorithmus terminiert, also die Abbruchbedingung irgendwann erfüllt wird Wir können die Korrektheit einer Schleife rein statisch prüfen ohne sie durchzuführen László Böszörményi ESOP Anweisungen - 19

Multiplikation mit Zusicherung static void main(string [] args) { // Multiplikation mit nur + und - int x, y, result, step; // Idee: wir addieren xy-mal zu result x = ReadPosInt(); y = ReadPosInt(); // x und y sind > 0 result = 0; step = y; // step ist > 0 /* Q: result == x * y, I: result + (step * x) == x * y */ if (result + (step * x)!= x * y) {Generiere Fehler...} // Zusicherung while (step > 0) { // B: step = 0 result += x; // result = result + x step--; // step = step -1 if (result + (step * x)!= x * y) {Generiere Fehler...} // Zusicherung } // B I Q: Wenn step == 0, I ergibt: result == x * y } // main László Böszörményi ESOP Anweisungen - 20

Do-While-Schleife Allgemeine Form: do Schleifenkörper while (Bedingung) Ausführung 1. Der Schleifenkörper (Anweisung) wird ausgeführt 2. Die Bedingung (logischer Ausdruck) wird ausgewertet 3. Ist sie wahr: es geht wieder von 1. weiter 4. Ist sie falsch: Nächste Anweisung wird ausgeführt Beispiel: Eingabekontrolle wird einfacher int x; do { // Harrt aus, solange eine positive Zahl kommt Out.print("Geben Sie bitte eine positive Zahl ein = "); x = In.readInt(); } while (x <= 0); // do-while Äquivalenz von while und do-while while (B) A if (B) do A while B // A wird eventuell nie ausgeführt do A while B A; while (B) A // A wird einmal immer ausgeführt László Böszörményi ESOP Anweisungen - 21

Primzahltest mit Do-While-Schleife static void main(string [] args) { // Primzahltest int k, i; String s = "Keine Primzahl"; Out.println("Primzahltest, bitte positive Zahl eingeben"); k = ReadPosInt(); // Ist k Primzahl? if (k > 3) { i = 1; do // Anfang der do-schleife i++; // Erhöhe i, solange bis while ((k % i)!= 0 && i * i <= k); // i nicht k teilt oder i 2 > k if ((k % i) == 0) s = "Teilbar durch " + i; // Keine Primzahl else s = "Primzahl"; // Wenn i k nicht teilt: Primzahl } // if (k > 3) else if (k > 0) s = "Primzahl"; Out.println(s); Für Eingabe 19 : Primzahl } // main Für Eingabe 20 : Teilbar durch 2 Immer true László Böszörményi ESOP Anweisungen - 22

For-Schleife Allgemeine Form for (Vorbereitung; Bedingung; Fortschaltung) Schleifenkörper Die Vorbereitung enthält Deklarationen und Anweisungen Die Deklarationen sind bis Ende der Schleife gültig Die Fortschaltung enthält nur Anweisungen, ist nicht ersetzbar durch einen Block (ist eigentlich ein Ausdruck) Ausführung 1. Vorbereitung wird ausgeführt (Meistens Laufvariablen werden initialisiert) 2. Die Bedingung wird ausgewertet 1. Ist sie wahr 1. Schleifenkörper (Anweisung bzw. Block) wird ausgeführt 2. Fortschaltung wird ausgeführt 3. Es geht wieder von der Auswertung der Bedingung weiter 2. Ist sie falsch: Die nächste Anweisung wird ausgeführt László Böszörményi ESOP Anweisungen - 23

Eigenart der for-schleife Durch die Selbstverwaltung der Fortschaltung etwas erhöhte Korrektheit und Kompaktheit Laufvariablen sollten im Körper nicht verändert werden! Besonders geeignet für arrays (siehe später) for (int i = 1; i < 10; i++) { println("i = " + i); } // Zahlen 1 bis 9 println("i = " + i); // Fehler: i ist nicht gültig for (char c = 'a'; c <= 'k'; c++) println("c = " + c); // 'a' bis 'k' for (float i = 1.5f; i < 10; i++) println("i = " + i); // 1.5 bis 9.5 for (int i = 1; i < 10; i++) { println("i = " + i); i--; // Unendliche Schleife! } // for i Steht für Out.println László Böszörményi ESOP Anweisungen - 24

Auswahl (Switch-Anweisung) Allgemeine Form switch (ganzzahliger Ausdruck) { case Konstante 1 : Anweisung 1 break;... case Konstante n : Anweisung n break; default : Anweisung n+1 break; } // switch Die Konstanten sind disjunkt ( i j, Konstante Konstante i j ) Ausführung 1. Der ganzzahlige Ausdruck wird ausgewertet 2. Ist sein Wert == Konstante i, : Anweisung i wird ausgeführt 3. Durch break wird die switch-anweisung verlassen Ohne break geht es weiter auf Fall i+1 Designfehler! (aus C geerbt) 4. Gibt es keine solche Konstante und Es gibt einen default-zweig: Anweisung n+1 wird ausgeführt Es gibt kein default: Die nächste Anweisung wird ausgeführt László Böszörményi ESOP Anweisungen - 25

Switch mit und ohne break int x ; String s = ""; Out.println("Bitte x eingeben"); x = In.readInt(); switch (x % 2) { // Ergibt den Rest von x/2 case 0: s = "gerade"; break; // Rest == 0: gerade case 1: s = "ungerade"; break; // Rest == 1: ungerade } // switch Out.println(x + " ist " + s); Ausgabe für 1 bzw. 2: 1 ist ungerade bzw. 2 ist gerade Ohne break auch für 2: 2 ist ungerade natürlich falsch! László Böszörményi ESOP Anweisungen - 26

Switch für Fallunterscheidung static void main(string [] args) { String s = ""; Out.println("Tippen Sie 1 fuer Fall1, 2 fuer Fall2... 7 fuer Fall7"); switch (In.readInt()) { // Ideal für Fallunterscheidungen, wie Menüs case 1: s = "Fall1"; break; case 2: s = "Fall2"; break; case 3: s = "Fall3"; break; case 7: s = "Fall7"; break; // Reihenfolge egal wenn break da ist case 4: s = "Fall4"; break; case 5: s = "Fall5"; break; case 6: s = "Fall6"; break; default:s = "Default"; } // switch Out.println("Aktion fuer " + s); } // main Tippen Sie 1 fuer Fall1,... 7 fuer Fall7 4 Aktion fuer 4 Tippen Sie 1 fuer Fall1,... 7 fuer Fall7 0 Aktion fuer Default László Böszörményi ESOP Anweisungen - 27

Viele gleiche Fälle switch umständlich switch (ch) { // Bestimmt die Art eines Zeichens Ziffer, Kleinbuchstabe etc. case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': s = "Ziffer"; break; case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': s = "Kleinbuchstabe"; break; default: s = "weder Ziffer noch Kleinbuchstabe"; } // switch Bei zu vielen gleich zu behandelnden Fällen ist switch umständlich if (ch >= 'a' && ch <= 'z')... wäre einfacher allerdings etwas langsamer László Böszörményi ESOP Anweisungen - 28

Äquivalenz von if und switch Ein switch kann immer durch if(s) ersetzt werden Ein if kann nicht immer durch switch ersetzt werden Die Fälle in switch sind nur durch Konstanten beschreibbar Achtung auf Seiteneffekte Folgende Lösungen sind nicht äquivalent: switch (In.readInt()) {//liest einmal // liest dreimal case 1: s = "Fall1"; break; if (In.readInt() == 1) s = "Fall1"; case 2: s = "Fall2"; break; else if (In.readInt() == 2) s = "Fall2"; case 3: s = "Fall3"; break; else if (In.readInt() == 3) s = "Fall3"; default: s = "Default"; break; else s = "Default"; } // switch Lösung: Operationen mit Seiteneffekt absondern (In.readInt ändert die Umgebung: liest jedes mal neu): int i = In.readInt(); switch (i) {...} int i = In.readInt(); if (i == 1) {...} else if (i == 2) {...}... László Böszörményi ESOP Anweisungen - 29