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

Programmierkurs Java Vorlesung 5 Dietrich Boles Seite 1

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> ] }

„;“

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!

Semantik:– Reservierung von Speicherplatz

– Initialisierung (implizit / explizit)


Anweisungen / Zuweisung(-sanweisung)

<Zuweisungsausdruck> ::= <Variablenname> „=“ <Ausdruck>

<Zuweisung> ::= <Zuweisungsausdruck> „;“

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!

Semantik:– Berechnung des Ausdrucks

– Zuweisung des berechneten Wertes an die Variable


Anweisungen / Ausdrucksanweisung

<Ausdrucksanweisung> ::= <Ausdruck>

„;“

Beispiele:

int anzahl, schritte;

anzahl = schritte / 3.5;

boolean linksFrei() {

linksUm(); return vornFrei();

}

linksFrei();

Einschränkung:– Zuweisungsausdrücke

– Funktionsaufrufe

Semantik:– Berechnung des Ausdrucks


Anweisungen / Block(anweisung)

<Block> ::= „{“ { <Anweisung> } „}“

Beispiele:{ int anzahl = 3;

anzahl++; { { } int schritte = 4; anzahl = schritte; } anzahl *= anzahl - 3; schritte++; // <- Syntaxfehler: Variable ungültig }

Semantik:– keine Auswirkungen auf den Programmablauf


Anweisungen / if-Anweisung<if-Anweisung> ::= „if“ „(“ <boolescher Ausdruck> „)“

<Anweisung 1>

[ „else“ <Anweisung 2> ]

Beispiele:int anzahl = 2, schritte = 3, speicher;

if (anzahl <= schritte) speicher = anzahl; else speicher = schritte;

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


Anweisungen / if-Anweisung

Beispiele:int anzahl = -2, schritte = 3;

if (anzahl >= schritte) anzahl = schritte; schritte = 2 * schritte;

if (anzahl >= schritte) { anzahl = schritte; schritte = 2 * 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) { if (anzahl > 5) System.out.println(„anzahl > 5“); } else System.out.println(„anzahl <= 1“);


Anweisungen / Leeranweisung

<Leeranweisung> ::= „;“

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>

Beispiel:int anzahl = 2, schritte = 2;

while (anzahl <= schritte) { System.out.println(anzahl); anzahl++; }

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


Anweisungen / do-Anweisung

<do-Anweisung> ::= „do“ <Anweisung>

„while“

„(“ <boolescher Ausdruck> „)“ „;“

Semantik:– führe Anweisung aus– berechne den Ausdruck– falls Ausdruck true liefert, führe Anweisung erneut aus; ...– falls false liefert, beende die while-Anweisung

Sinn und Zweck:– Schleife mit mindestens einmaliger Ausführung einer 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>) { <Anweisung1> <Inkr-Ausdr>; } }

Äquivalenz gilt u.U. nicht bei Verwendung der continue-Anweisung



Beispiele:

for (int schritte = 1; schritte < 5; schritte++)

System.out.println(schritte);

<=>

{ int schritte = 1;

while (schritte < 5) {

System.out.println(schritte);

schritte++;

} }

<=>

{ int schritte = 1;

for (;;) {

System.out.println(schritte++);

if (schritte == 5) break;

} }



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

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


Anweisungen / Label-Anweisung

<Label-Anweisung> ::= <Label> „:“ <Anweisung>

<Label> ::= <Bezeichner>

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> ] „;“

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

Sinn und Zweck:– vorzeitiges Verlassen eines Blockes

– kein goto!

Beispiel:int schritte = 5;

for (;;) { ... if (schritte == 10) break; ... }



###

#

###

#

##

#

# # # # # # # # # # # # # # # #

Beispiel: Der Hamster soll das Korn fressen!

>

o



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++; }



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“ „:“

Sinn und Zweck:– größere Fallunterscheidung

– effizienter als geschachtelte if-Anweisung

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


Anweisungen / switch-AnweisungSemantik:

– 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“); break; default: System.out.println(„i != (1/2/3)“); }


Anweisungen / switch-AnweisungBeispiel:

char ch = à`; 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 à`: case `b`: case `c`: case `d`: case è`: case `f`: hex_wert = (ch - à`) + 10; break; case À`: case `B`: case `C`: case `D`: case È`: case `F`: hex_wert = (ch - À`) + 10; break; } if (hex_wert != -1) System.out.println(hex_wert); else System.out.println(„ungueltiges Zeichen“);


Anweisungen / continue-Anweisung

<continue-Anweisung> ::= „continue“ [ <Label> ] „;“

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

Sinn und Zweck:– ans Ende eines Schleifenrumpes springen

Beispiel:int x = 0;

while (x < 10) { x = x + 1; if (x < 10) continue; System.out.println(„x == 10“); }


Anweisungen / continue-AnweisungBeispiele:

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 System.out.println(schritte); } schritte++; } }

Grund: Bei der for-Schleife wird noch der Inkr-Ausdruck ausgewertet!


Anweisungen / return-Anweisung

<return-Anweisung> ::= „return“ [ <Ausdruck> ] „;“

Semantik:– die Prozedur/Funktion/Methode wird unmittelbar verlassen

– falls ein Ausdruck existiert, wird sein Wert berechnet und dieser als Funktionswert zurückgeliefert

Sinn und Zweck:– Verlassen einer Prozedur/Funktion/Methode

– Lieferung eines Wertes

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 ProbeEnter op1:2.5<CR>Enter op2:2.0<CR>2.5 * 2.0 = 5.0$

$ java ProbeEnter 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

$ java Umkehr

Zahl:

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 PasstKlein:h<CR>Gross:H<CR>passen$ java PasstKlein:d<CR>Gross: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 RechnerZahl 1 eingeben:-23<CR>Zahl 2 eingeben:2<CR>Operator eingeben:*<CR>-46Zahl 1 eingeben:0<CR>Zahl 2 eingeben:0<CR>Operator eingeben:q<CR>$


Beispielprogramm 3import 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 RechteckHoehe 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(‘|‘); for (int i=2; i<breite; i++) Terminal.out.print(‘ ‘); Terminal.out.println(‘|‘); }

// letzte Zeile ausgeben Terminal.out.print(‘+‘); for (int i=2; i<breite; i++) Terminal.out.print(‘-‘); Terminal.out.println(‘+‘); }}

Documents

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