der Universität Oldenburg Programmierkurs Java Vorlesung am FB Informatik der Universität Oldenburg Vorlesung 5 Dietrich Boles

Gliederung von Vorlesung 5 Java-Anweisungen Grundlagen Deklarationsanweisung Ausdrucksanweisung Zuweisung Blockanweisung if-Anweisung Leeranweisung while-Schleife do-Schleife for-Schleife Labelanweisung break-Anweisung switch-Anweisung continue-Anweisung return-Anweisung Ein- / Ausgabe in Java Ausgabe Eingabe Klasse Terminal Beispielprogramme

Anweisungen / Grundlagen Definition: Anweisung = Vorschrift zur Verarbeitung von Daten Klassifikation: elementare Anweisungen zusammengesetzte Anweisungen Anweisungen zur Ablaufsteuerung Imperative Programmierung = sequentielles Abarbeiten von Anweisungen

Anweisungen / Deklaration(-sanweisung) <Deklaration> ::= <Typ> <Bezeichner> [ „=“ <Ausdruck> ] { „,“ <Bezeichner> [ „=“ <Ausdruck> ] } „;“ Semantik: Reservierung von Speicherplatz Initialisierung (implizit / explizit) Beispiele: int anzahl; char ziffer = ´1´; double d1, d2 = 3.12, d3 = d2 * d1; Bedingungen: Typkonformität zwischen Variable und Initialisierungsausdruck! Variablenname darf nicht im eigenen Initialisierungsausdruck auftreten!

Anweisungen / Zuweisung(-sanweisung) <Zuweisungsausdruck> ::= <Variablenname> „=“ <Ausdruck> <Zuweisung> ::= <Zuweisungsausdruck> „;“ Semantik: Berechnung des Ausdrucks Zuweisung des berechneten Wertes an die Variable Beispiele: int anzahl = 2, schritte = 4; anzahl = 2 * anzahl + schritte / 3; if ((anzahl = anzahl++) == (anzahl = anzahl--)) anzahl = schritte = 4 * anzahl; Bedingungen: Bezeichner ist der Name einer „gültigen“ Variablen! Typkonformität zwischen Variable und Zuweisungsausdruck!

Anweisungen / Ausdrucksanweisung <Ausdrucksanweisung> ::= <Ausdruck> „;“ Einschränkung: Zuweisungsausdrücke Funktionsaufrufe Semantik: Berechnung des Ausdrucks Beispiele: int anzahl, schritte; anzahl = schritte / 3.5; boolean linksFrei() { linksUm(); return vornFrei(); } linksFrei();

Anweisungen / Block(anweisung) Semantik: keine Auswirkungen auf den Programmablauf Beispiele: { int anzahl = 3; anzahl++; { { } int schritte = 4; anzahl = schritte; } anzahl *= anzahl - 3; schritte++; // <- Syntaxfehler: Variable ungültig

Anweisungen / if-Anweisung <if-Anweisung> ::= „if“ „(“ <boolescher Ausdruck> „)“ <Anweisung 1> [ „else“ <Anweisung 2> ] Semantik: berechne den Ausdruck falls Ausdruck true liefert, führe Anweisung 1 aus falls else-Teil existiert und Ausdruck false liefert, führe Anweisung 2 aus Beispiele: int anzahl = 2, schritte = 3, speicher; if (anzahl <= schritte) speicher = anzahl; else speicher = schritte;

Anweisungen / if-Anweisung Beispiele: int anzahl = -2, schritte = 3; if (anzahl >= schritte) anzahl = schritte; schritte = 2 * schritte; if (anzahl >= schritte) { } if (anzahl < schritte) System.out.println(„anzahl ist kleiner“); else if (anzahl > schritte) System.out.println(„anzahl ist groesser“); else System.out.println(„gleich“);

Anweisungen / if-Anweisung Beispiele: int anzahl = -2, schritte = 3; if (anzahl > 1) if (anzahl > 5) System.out.println(„anzahl > 5“) else System.out.println(„anzahl zwischen 2 und 5“); if (anzahl > 1) { System.out.println(„anzahl > 5“); } else System.out.println(„anzahl <= 1“);

Anweisungen / Leeranweisung Semantik: keine Auswirkungen auf den Programmablauf Beispiele: double speed = 2.3; scale = 0.6; if (speed >= 3.4) ; else speed *= scale;; if (scale <= 1.0) { scale = 1.0 / scale; }; else // <- Syntaxfehler scale = scale / 1.1;

Anweisungen / while-Anweisung <while-Anweisung> ::= „while“ „(“ <boolescher Ausdruck> „)“ <Anweisung> Semantik: berechne den Ausdruck falls Ausdruck true liefert, führe Anweisung aus; berechne Ausdruck anschließend erneut; ... falls Ausdruck false liefert, beende die while-Anweisung Beispiel: int anzahl = 2, schritte = 2; while (anzahl <= schritte) { System.out.println(anzahl); anzahl++; }

Anweisungen / do-Anweisung <do-Anweisung> ::= „do“ <Anweisung> „while“ „(“ <boolescher Ausdruck> „)“ „;“ Sinn und Zweck: Schleife mit mindestens einmaliger Ausführung einer Anweisung Semantik: führe Anweisung aus berechne den Ausdruck falls Ausdruck true liefert, führe Anweisung erneut aus; ... falls false liefert, beende die while-Anweisung

Anweisungen / do-Anweisung Semantische Äquivalenz: <anweisung1> while (<bedingung>) <anweisung1> <=> do <anweisung1> while (<bedingung>); Beispiel: int anzahl = 2, schritte = 2; do { System.out.println(anzahl); anzahl++; } while (anzahl <= schritte);

Anweisungen / for-Anweisung <for-Anweisung> ::= „for“ „(“ [ <Init-Anweisung> ] [ <boolescher Ausdruck> ] „;“ [ <Inkrement-Ausdruck> ] „)“ <Anweisung> Sinn und Zweck: Durchlaufen eines Wertebereiches Semantik: führe Init-Anweisung aus berechne den booleschen Ausdruck falls Ausdruck true liefert: führe Anweisung aus; berechne den Inkrement-Ausdruck; berechne erneut den booleschen Ausdruck; ... falls Ausdruck false liefert, beende die for-Anweisung

Anweisungen / for-Anweisung Semantische Äquivalenz: for (<Init-Anweis> <bool-Ausdr>; <Inkr-Ausdr>) <Anweisung1> <=> (i.a.) { // wegen Gültigkeitsbereich der Init-Anweisung <Init-Anweis> while (<bool-Ausdr>) { <Inkr-Ausdr>; } Äquivalenz gilt u.U. nicht bei Verwendung der continue-Anweisung

Anweisungen / for-Anweisung Beispiele: for (int schritte = 1; schritte < 5; schritte++) System.out.println(schritte); <=> { int schritte = 1; while (schritte < 5) { schritte++; } } for (;;) { System.out.println(schritte++); if (schritte == 5) break;

Anweisungen / for-Anweisung Ergänzung: wird eine Variable in der Init-Anweisung definiert, so erstreckt sich ihr Gültigkeitsbereich über die gesamte for-Anweisung (aber nicht weiter) die Init-Anweisung und der Inkr-Ausdruck können eine durch Kommata getrennte Liste von Ausdrücken enthalten Auswertung der Ausdrücke von links nach rechts Beispiele: int i,j; for (i = 0, j = 4; i < 5; i++, j--) { System.out.println(i); System.out.println(j); } for (int x=0; x<3; x++) System.out.println(x); System.out.println(x); // Fehler: x ungültig

Anweisungen / Label-Anweisung <Label-Anweisung> ::= <Label> „:“ <Anweisung> <Label> ::= <Bezeichner> Semantik: keine Auswirkungen auf den Programmablauf Beispiele: deklariere: int anzahl = 3; berechne_wiederholt: while (anzahl <= 3) { berechne: anzahl += 2; } gebe_aus: System.out.println(„hello world!“);

Anweisungen / break-Anweisung <break-Anweisung> ::= „break“ [ <Label> ] „;“ Sinn und Zweck: vorzeitiges Verlassen eines Blockes kein goto! Semantik: fehlt das Label, so wird das innerste do, while, for oder switch verlassen existiert ein umgebendes do, while, for oder switch mit einem angegebenen Label, so wird dieses verlassen Beispiel: int schritte = 5; for (;;) { ... if (schritte == 10) break; }

Anweisungen / break-Anweisung Beispiel: Der Hamster soll das Korn fressen! # # # o # # # # # # # > # # # # # # # # # # # # # # # # #

Anweisungen / break-Anweisung Beispiel (ohne break): int radius = 1; boolean gefund = false; hauptprogramm: while (!gefunden) { // teste einen Kreis for (int richt=0; richt<4 && !gefund; richt++) { // teste eine Richtung for (int anz=0; anz<radius && !gefund; anz++) { vor(); if (korn_da()) { nimm(); gefund = true; } } // Ende teste eine Richtung if (!gefund) links_um(); } // Ende teste einen Kreis if (!gefund) radius++;

Anweisungen / break-Anweisung Beispiel (mit break): int radius = 1; hauptprogramm: while (true) { // teste einen Kreis for (int richt=0; richt<4; richt++) { // teste eine Richtung for (int anz=0; anz<radius; anz++) { vor(); if (korn_da()) { nimm(); break hauptprogramm; } } // Ende teste eine Richtung links_um(); } // Ende teste einen Kreis radius++;

Anweisungen / switch-Anweisung <switch-Anweisung> ::= „switch“ „(“ <Ausdruck> „)“ „{“ { <Fallunterscheid> } „}“ <Fallunterscheid> ::= <Anweisung> | „case“ <const-Ausdruck> „:“ | „default“ „:“ Bedingungen: const-Ausdrücke vom Typ char, byte, short oder int (Literal) alle const-Ausdrücke vom selben Typ keine doppelte const-Ausdrücke Typ von Ausdruck konform zum Typ der const-Ausdrücke höchstens ein default Sinn und Zweck: größere Fallunterscheidung effizienter als geschachtelte if-Anweisung

Anweisungen / switch-Anweisung Semantik: werte Ausdruck aus falls ein const-Ausdruck mit dem berechneten Wert existiert: springe an die entsprechende Stelle und fahre dort mit der Programmausführung fort falls kein entsprechender const-Ausdruck existiert falls default existiert: fahre beim default mit der Ausführung fort ansonsten: beende switch-Anweisung Beispiel: int i = 5; switch (i) { case 1: System.out.println(„i == 1“); // FAHRE FORT case 2: System.out.println(„i == (1 oder 2)“); break; case 3: System.out.println(„i == 3“); default: System.out.println(„i != (1/2/3)“); }

Anweisungen / switch-Anweisung Beispiel: char ch = `a`; int hex_wert = -1; switch (ch) { case `0`: case `1`: case `2`: case `3`: case `4`: case `5`: case `6`: case `7`: case `8`: case `9`: hex_wert = ch - `0`; break; case `a`: case `b`: case `c`: case `d`: case `e`: case `f`: hex_wert = (ch - `a`) + 10; break; case `A`: case `B`: case `C`: case `D`: case `E`: case `F`: hex_wert = (ch - `A`) + 10; break; } if (hex_wert != -1) System.out.println(hex_wert); else System.out.println(„ungueltiges Zeichen“);

Anweisungen / continue-Anweisung <continue-Anweisung> ::= „continue“ [ <Label> ] „;“ Sinn und Zweck: ans Ende eines Schleifenrumpes springen Semantik: fehlt das Label, so wird an das Ende der Schleifenanweisung des innersten do, while oder for gesprungen existiert eine umgebende Schleife mit einem angegebenen Label, so wird an das Ende der Schleifenanweisung dieser Schleife gesprungen Beispiel: int x = 0; while (x < 10) { x = x + 1; if (x < 10) continue; System.out.println(„x == 10“); }

Anweisungen / continue-Anweisung Beispiele: for (int schritte=1; schritte<5; schritte++) { if (schritte < 3) continue; System.out.println(schritte); } !<=> { int schritte = 1; while (schritte < 5) { if (schritte < 3) continue; // Endlosschleife schritte++; Grund: Bei der for-Schleife wird noch der Inkr-Ausdruck ausgewertet!

Anweisungen / return-Anweisung <return-Anweisung> ::= „return“ [ <Ausdruck> ] „;“ Sinn und Zweck: Verlassen einer Prozedur/Funktion/Methode Lieferung eines Wertes Semantik: die Prozedur/Funktion/Methode wird unmittelbar verlassen falls ein Ausdruck existiert, wird sein Wert berechnet und dieser als Funktionswert zurückgeliefert Beispiel: public static int abs(int wert) { if (wert >= 0) return wert; else return -wert; }

Ein- / Ausgabe Eingabe: Lesen von Zeichen von/aus Tastatur Datei Zeichenkette Socket (Netzwerk) ... In Java sehr flexibel: Paket java.io (siehe VL 15) zunächst vereinfacht für Terminal-IO: Klasse Terminal zur Nutzung auf ARBI-Cluster /user/fb10/dibo/java in CLASSPATH-Variable aufnehmen; bash-Shell-Syntax: export CLASSPATH=$CLASSPATH:/user/fb10/dibo/java Ausgabe: Schreiben von Zeichen auf/in Bildschirm Datei Drucker Zeichenkette Socket ...

Ein- / Ausgabe / Klasse Terminal package dibo; public class Terminal { // für Ausgabe; Methoden print/println benutzen public static PrintStream out = System.out; // für Eingabe: Lesen Zeile bis <CR> von Tastatur ein // und liefern den entsprechenden Wert zurück; im // Fehlerfall wird `\0`, 0, 0.0 bzw. ““ geliefert public static char readChar() {...} public static short readShort() {...} public static int readInt() {...} public static long readLong() {...} public static float readFloat() {...} public static double readDouble() {...} public static String readString() {...} }

Ein- / Ausgabe / Klasse Terminal import dibo.*; public class Probe { public static void main(String[] args) { Terminal.out.println(“Enter op1: “); double op1 = Terminal.readDouble(); Terminal.out.println(“Enter op2: “); float op2 = Terminal.readFloat(); Terminal.out.print(op1 + “ * “ + op2 “ = “); Terminal.out.println(op1*op2); } } $ java Probe Enter op1: 2.5<CR> Enter op2: 2.0<CR> 2.5 * 2.0 = 5.0 $ $ java Probe Enter op1: 3.1<CR> Enter op2: -2.0<CR> 3.1 * -2.0 = -6.2 $

Beispielprogramm 1 Schreiben Sie ein Programm „Umkehr“, das zunächst einen int-Wert von der Tastatur einliest und diesen dann in umgekehrter Reihenfolge wieder ausgibt. Beispiel: $ java Umkehr Zahl: 3567<CR> 7653 1210<CR> 0121 $ import dibo.*; public class Umkehr { public static void main(String[] a) { Terminal.out.println(“Zahl:“); int zahl = Terminal.readInt(); while (zahl > 0) { Terminal.out.print(zahl % 10); zahl = zahl / 10; } Terminal.out.println();

Beispielprogramm 2 Schreiben Sie ein Programm „Passt“, das zunächst einen Kleinbuchstaben und dann einen Großbuchstaben einliest und dann überprüft, ob diese zueinander passen, d.h. Kleinbuchstabe entspricht Großbuchstaben. Beispiel: $ java Passt Klein: h<CR> Gross: H<CR> passen d<CR> E<CR> passen nicht import dibo.*; public class Passt { public static void main(String[] a) { Terminal.out.println(“Klein:“); char klein = Terminal.readChar(); Terminal.out.println(“Gross:“); char gross = Terminal.readChar(); if (klein-‘a‘==gross-‘A‘) Terminal.out.println(“passen“); else Terminal.out.println(“passen nicht“); }

Beispielprogramm 3 Schreiben Sie ein Programm „Rechner“, das zunächst zwei Zahlen und dann einen Buchstaben (Operatorzeichen) einliest, das Ergebnis berechnet und dieses ausgibt. Dieses soll sich wiederholen, bis der Nutzer als Operator ein ‘q‘ (für „quit“) eingibt. Beispiel: $ java Rechner Zahl 1 eingeben: -23<CR> Zahl 2 eingeben: 2<CR> Operator eingeben: *<CR> -46 0<CR> q<CR> $

Beispielprogramm 3 import dibo.*; public class Rechner { public static void main(String[] a) { hauptprogramm: while (true) { Terminal.out.println(“Zahl 1 eingeben:“); int zahl1 = Terminal.readInt(); Terminal.out.println(“Zahl 2 eingeben:“); int zahl2 = Terminal.readInt(); Terminal.out.println(“Operator eingeben:“); char operator = Terminal.readChar(); switch (operator) { case ‘+‘: Terminal.out.println(zahl1+zahl2); break; case ‘-‘: Terminal.out.println(zahl1-zahl2); break; case ‘*‘: Terminal.out.println(zahl1*zahl2); break; case ‘/‘: Terminal.out.println(zahl1/zahl2); break; case ‘%‘: Terminal.out.println(zahl1%zahl2); break; case ‘q‘: break hauptprogramm; default: Terminal.out.println(“ungueltiger Op“); break; } } } }

Beispielprogramm 4 Schreiben Sie ein Programm „Rechteck“, das zunächst eine Zahl hoehe einliest, die größer als 1 ist, dann eine Zahl breite einliest, die größer als 1 und kleiner als 10 ist, und anschließend ein „Rechteck“ mit der Höhe hoehe und der Breite breite in folgender Gestalt auf den Bildschirm ausgibt: Beispiel: $ java Rechteck Hoehe eingeben: 4<CR> Breite eingeben: 5<CR> +---+ | | $

Beispielprogramm 4 import dibo.*; public class Rechteck { public static void main(String[] a) { // richtige Hoehe einlesen Terminal.out.println(„Hoehe eingeben:“); int hoehe = Terminal.readInt(); while (hoehe < 2) { Terminal.out.println(„Fehler; Hoehe eingeben:“); hoehe = Terminal.readInt(); } // richtige Breite einlesen Terminal.out.println(„Breite eingeben:“); int breite = Terminal.readInt(); while (breite < 2 || breite > 9) { Terminal.out.println(„Fehler; Breite eingeben:“); breite = Terminal.readInt();

Beispielprogramm 4 // Rechteck ausgeben // erste Zeile ausgeben Terminal.out.print(‘+‘); for (int i=2; i<breite; i++) Terminal.out.print(‘-‘); Terminal.out.println(‘+‘); // mittlere Zeilen ausgeben for (int j=2; j<hoehe; j++) { Terminal.out.print(‘|‘); Terminal.out.print(‘ ‘); Terminal.out.println(‘|‘); } // letzte Zeile ausgeben