Kapitel 5.4 - Department of Information Systems

5.4 Java Syntaxkonstrukte
5.4.1 Primitive Datentypen, Literale und Variablen
5.4.2 Aufruf von Objekten, einfacher Nachrichtenaustausch
5.4.3 Operatoren, Ausdrücke, Zuweisungen
5.4.4 Anweisungen
Informatik I – Java
© Klaus Hinrichs
5-31
5.4.1 Primitive Datentypen, Literale und Variablen
• Primitive Datentypen
– Ganze Zahlen:
– Fließkommazahlen:
– Andere Typen:
byte
float
char
short
int
double
boolean
long
• Keine primitiven Datentypen sind:
String, Arrays (auch von einfachen Typen), Klassen allgemein
• Ganze Zahlen:
– 2er Komplement Darstellung
– vorzeichenbehaftet
– feste Größe, unabhängig von Maschinenwortgröße
Typ
byte
short
int
long
© Klaus Hinrichs
Größe
8 Bit (1 Byte)
16 Bit (2 Byte)
32 Bit (4 Byte)
64 Bit (8 Byte)
Wertbereich
–27…0…(27–1)
–215…0…(215–1)
–231…0…(231–1)
–263…0…(263–1)
Informatik I – Java
5-32
Primitive Datentypen: Fließkommazahlen
• Fließkommazahlen:
– Fließkommazahlen nach IEEE 745
– Mantisse und Exponent definieren Wert
– Unendlich ist ein definierter Wert:
POSITIVE_INFINITY
NEGATIVE_INFINITY
– NaN (Not a number) ist ein definierter Wert
Typ
Größe
Wertbereich Genauigkeit
float 32 Bit (4 Byte) ±3.4·1038
~ 7 Dezimalen
308
double 64 Bit (8 Byte) ±1.8·10
~ 15.5 Dezimalen
• Fließkommazahlen nach IEEE 745 setzen sich zusammen aus:
– Sign-Bit S (1 Bit)
– Exponent E (8 Bit für float und 11 Bit für double)
– Mantisse M (23 Bit für float und 52 Bit für double)
Alle Bits in E gesetzt ! Darstellung für Unendlich und NaN
© Klaus Hinrichs
Informatik I – Java
5-33
Primitive Datentypen: boolean und char
• boolean kennt nur zwei Werte, true und false
• Sämtliche boolsche Logik in Java wird mit dem Datentyp boolean
realisiert. Mißbrauch von Integertypen für boolsche Ausdrücke, wie in
C und C++ üblich, ist in Java nicht vorgesehen.
• boolean benötigt 1 Byte (= 8 Bit) Speicher. Dies liegt nicht an der
Java-Sprachsyntax, sondern am Mapping auf die Virtual Machine, die
keine 1-Bit-Datentypen kennt.
• char ist ein 16-Bit-Zeichen nach dem Unicode-Standard
• Untere 7 Bit (128 Zeichen) von Unicode sind ASCII-kompatibel
(bzgl. ASCII nach ANSI X3.4)
• Sonstige Bits werden benötigt, um internationale Zeichensätze
abbilden zu können.
• Verantwortlich ist das Unicode Consortium (http:// www.unicode.org)
© Klaus Hinrichs
Informatik I – Java
5-34
Klasse String
• Zeichenketten werden durch Objekte der Klasse String dargestellt
• allgemeine Objekte und Klassen werden später gründlicher
untersucht
• String ist jedoch besondere Klasse, da Literale (konstante
Zeichenketten) und Operatoren (+ zur Konkatenation) definiert sind
• Anders als in C/ C++ sind Strings keine Zeiger auf char bzw. Array
von char, in Java gibt es keine Zeiger, und Arrays sind gesonderte
Konstruktionen, die nichts mit der Klasse String zu tun haben
Informatik I – Java
© Klaus Hinrichs
5-35
Primitive Datentypen in Java
Anwendung
Java-Datentyp
Beispiel
Logik
boolean
true
Buchstaben
char
'a' 'b' 'c' ...
Ganze Zahlen
byte (8 Bit)
short (16 Bit)
int (32 Bit)
long (64 Bit)
-13
Fließkomma
float (32 Bit)
double (64 Bit)
-3.3e-22f
3.4E32
© Klaus Hinrichs
Informatik I – Java
false
-1
0
1
5-36
Literale
• Literale sind konstante Zahlen, Zeichen bzw. Zeichenketten, die zur
Initialisierung von Datentypen verwendet werden.
• Jedes Literal hat einen eindeutigen Typ, bei Zuweisungen muß auf
Typkonsistenz geachtet werden.
• Literale existieren für die einfachen Datentypen
int long float double char boolean
sowie für die Klasse String.
Es gibt keine Literale für byte und short!
• Für den primitiven Datentyp boolean gibt es die Literale true und
false.
© Klaus Hinrichs
Informatik I – Java
5-37
Literale: Ganze Zahlen
• Ganze Zahlen lassen sich einfach durch den Dezimalwert darstellen,
z. B. 0 20 4332
• Ein Vorzeichen kann der Zahl vorangestellt werden,
z. B. -323 +4238
• Durch vorangestelltes 0x lassen sich Zahlen durch ihre
Hexadezimalwerte definieren. Die Buchstaben A bis F können hier
sowohl klein als auch groß geschrieben werden,
z.B. 0x3AF 0xfff178
• Durch eine vorangestelle Null 0 werden Zahlen im Oktalsystem
definiert, z. B. 0413 01114
• Standardmäßig sind Ganzzahlkonstanten vom Typ int, longKonstanten werden durch ein Anfügen des Buchstabens L bzw. l
erzeugt, z.B. 0L 100000000000L 375l
Achtung: l leicht mit 1 zu verwechseln, daher L benutzen
• Für die Datentypen byte und short existieren keine eigenen Literale,
es dürfen int-Literale verwendet werden, sofern der Wert klein genug.
© Klaus Hinrichs
Informatik I – Java
5-38
Literale: Fließkommazahlen …
• Fließkommazahlen bestehen aus einer Mantisse und einem optionalen
Exponenten (zur Basis 10).
• Der Exponent wird durch ein E bzw. e von der Mantisse getrennt,
z.B. entspricht 10E3 dem Wert 10000.
• Sowohl Mantisse als auch Exponent können vorzeichenbehaftet sein,
z.B.
-10E8
+3e-4
• Mantisse darf auch als Dezimalbruchdarstellung geschrieben werden,
z. B.
-5.334E+27
• Fließkommazahlen vom float-Typ lassen sich durch ein angefügtes f
bzw. F definieren, z.B.
7f
3.8F
• Fließkommazahlen vom double-Typ lassen sich durch ein angefügtes
d bzw. D definieren, z.B. 121D
1.4E7d
© Klaus Hinrichs
Informatik I – Java
5-39
… Literale: Fließkommazahlen
• Fließkommazahlen lassen sich als solche von ganzen Zahlen
unterscheiden, wenn eine der folgenden Eigenschaften erfüllt ist:
- Es existiert ein Exponent, z.B.
1E3
- Die Mantisse enthält den Dezimalpunkt, z.B. 3.0
- f , F , d oder D beendet das Literal.
• Ist ein Fließkommaliteral nicht durch f bzw. F spezifiziert, hat es den
Typ double.
© Klaus Hinrichs
Informatik I – Java
5-40
Literale: Zeichen …
• Zeichen (char-Literale) werden durch einfache Anführungsstriche
definiert, z.B. 'a' , '#' , '='
• Für Sonderzeichen gibt es Escape-Sequenzen, die durch einen
Backslash \ eingeleitet werden, z.B. '\n'
• Hierbei bedeutet:
'\b': backspace BS (Zeichen zurück) (ASCII: 8)
'\t': horizontal tab HT (horizontaler Tabulator) (ASCII: 9)
'\n': line feed LF (Zeilenvorschub) (ASCII: 10)
'\f': form feed FF (Seitenvorschub) (ASCII: 12)
'\r': carriage return CR (Wagenrücklauf) (ASCII: 13)
'\"': double quote (doppeltes Anführungszeichen)
'\'': single quote (einfaches Anführungszeichen)
'\\': backslash (Rückwärts-Schrägstrich)
© Klaus Hinrichs
Informatik I – Java
5-41
… Literale: Zeichen
• In einer Escape-Sequenz kann auch direkt der ASCII-Wert als
Oktalzahl angegeben werden, z. B.
'\17' '\3'
• Durch '\uxxxx' wird der Wert als Unicode-Sequenz angegeben,
wobei für jedes x eine Hexadezimalziffer angegeben werden muß,
z.B. '\u0022' entspricht '\"' )
• Achtung: die Unicode-Escape-Sequenzen werden in einer sehr
frühen Phase des Compilers ausgewertet.
Ein Zeilenvorschub als Unicode-Escape-Sequenz wird daher
genauso behandelt wie eine neue Zeile im Editor.
© Klaus Hinrichs
Informatik I – Java
5-42
String-Literale
• String: Folge von Zeichen.
• String-Literale werden durch doppelte Anführungszeichen
gekennzeichnet.
• Alle Zeichen lassen sich analog den char-Literalen konstruieren.
• Beispiele für String-Literale:
"Begrenzung durch Anführungszeichen"
"Das ist Text\nmit Zeilenvorschub"
© Klaus Hinrichs
Informatik I – Java
5-43
Variablen
• Variablen dienen dazu, Werte von speziellen Datentypen zu speichern
und zu verarbeiten, die gespeicherten Werte können während der
Ausführung eines Programms geändert werden, d.h. sie sind variabel.
• Die Werte, die eine Variable annehmen kann, sind durch ihren Typ
festgelegt.
• Als erster Schritt muß eine Variable dem Compiler bekannt gemacht
werden, diesen Vorgang nennt man Deklaration:
int kontostand;
• Dann muß ein Anfangswert (initialer Wert) zugewiesen werden, diesen
Vorgang nennt man Initialisierung:
kontostand = 0;
• Verkürzend können beide Aktionen auch in einer Zeile erledigt werden:
int kontostand = 0; Deklaration [mit Initialisierung]
Datentyp Variablenname [= Wert]
© Klaus Hinrichs
Informatik I – Java
5-44
Variablen und Variablennamen
• Ohne Deklaration kann keine Variable initialisiert werden.
• Ohne Initialisierung kann keine Variable weiterverarbeitet werden,
z.B. in Ausdrücken.
• Veränderung des Wertes einer Variablen durch Zuweisung
• Variablennamen (sowie alle Bezeichner in Java) sind case-sensitive,
man unterscheidet also zwischen Groß- und Klein-schreibung.
• Variablennamen beginnen stets mit Buchstaben (JavaLetter), dann
können Buchstaben oder Zahlen folgen.
• Der Unterstrich _ gehört aus historischen Gründen auch zu den
Buchstaben, kommt aber in der offiziellen Namenskonvention nicht
vor, sollte daher nicht verwendet werden.
© Klaus Hinrichs
Informatik I – Java
5-45
Deklaration
• Variablen werden durch den Typ gefolgt von dem Variablennamen
deklariert.
• Mehrere Variablennamen können durch Kommata getrennt
aufgeführt werden, sie sind dann vom gleichen Typ.
• Deklarationen sind Anweisungen, die mit Semikolon abgeschlossen
werden.
• Beispiel:
int anzahlPersonen;
long mSekSeitGeburt;
float groesseInCm, gewichtInKg;
String name, wohnort;
© Klaus Hinrichs
Informatik I – Java
5-46
Initialisierung von Variablen
• Initialisierungen werden durch =-Operator realisiert, der rechte Wert
wird dem linken zugewiesen. Beide Seiten des = müssen den gleichen
Typ haben. Initialisierungen werden mit Semikolon ; abgeschlossen.
• Beispiel:
anzahlPersonen = 20;
mSekSeitGeburt = 568000000000L;
groesseInCm = 185F;
name = "Hans Mustermann";
• Deklarationen und Initialisierungen können in einer Zeile erfolgen.
Mehrere Deklarationen vom gleichen Typ können durch Kommata
voneinander getrennt werden.
• Beispiel:
float groesseInCm = 185, gewichtInKg = 79;
String name = "Hans Mustermann";
© Klaus Hinrichs
Informatik I – Java
5-47
Typenkonversionen (Type Casting)
• Datentypen byte und short haben keine eigenen Literale.
• Es muß das Literal von int genommen werden und der Wert nach
byte bzw. short konvertiert werden (casting).
• Dies geschieht durch vorangestellte runde Klammern (Cast-Operator).
• Beispiel:
byte alterInJahren;
alterInJahren = (byte)18;
© Klaus Hinrichs
Informatik I – Java
5-48
5.4.2 Aufruf von Objekten, einfacher Nachrichtenaustausch
• Konstruktoren: Aktivitäten bei Objekterzeugung
• Referenzen als Verweise auf Objekte
• Garbage Collection
• Übergabe von Parametern an Methoden
• Klassenattribute / Klassenmethoden
• Namensraum
– Überladen von Methoden
– Überdecken von Attributen
• Vertiefung
OO-Programm = Mehrere Objekte + Nachrichtenaustausch
– Aufgaben verteilen ("Spezialisten")
© Klaus Hinrichs
Informatik I – Java
5-49
Konstruktoren …
• Konstruktor
– Methode, die für das Durchführen von Arbeiten bei Erzeugung
eines Objektes aufgerufen wird.
– Methode umfaßt Folge von Anweisungen, die abzuarbeiten sind.
– Methodenname stimmt mit dem Klassennamen überein:
Methodenname = Klassenname
– Wird in der Regel benutzt, um Attribute zu initialisieren.
– Konstruktoren besitzen keinen Rückgabewert (auch nicht void).
– Überladen von Konstruktoren ist möglich.
class Girokonto {
...
public Girokonto() {
kontostand = 0;
...
}
}
© Klaus Hinrichs
Informatik I – Java
5-50
… Konstruktoren …
• Argumente der Konstruktormethode werden bei Objekterzeugung durch
new Klassenname(Arg1, Arg2, ...)
an den Konstruktor übergeben.
class Girokonto {
...
public Girokonto(int kontostand) {
this.kontostand = kontostand;
...
}
public Girokonto() {
kontostand = 0;
...
}
}
© Klaus Hinrichs
Informatik I – Java
5-51
… Konstruktoren
Girokonto k1 = new Girokonto();
Girokonto k2 = new Girokonto(1000);
• Ohne Angabe eines Konstruktors ist nur der leere Konstruktor ohne
Argumente definiert.
• Ist ein (nicht leerer) Konstruktor definiert, muß der leere Konstruktor
explizit definiert werden, um noch benutzt werden zu dürfen.
© Klaus Hinrichs
Informatik I – Java
5-52
Referenzen auf Objekte …
• Bei primitiven Datentypen enthält eine Variable direkt den Inhalt (z. B.
einen int-Zahlenwert).
• Bei Objekten von Klassen symbolisiert die Variable nur eine Referenz
(einen Verweis) auf das Objekt.
• Es können auch mehrere Referenzen auf ein Objekt zeigen.
• Eine Referenz kann auch leer sein, null ist das Schlüsselwort für die
leere Referenz.
Girokonto k = null;
© Klaus Hinrichs
Informatik I – Java
5-53
… Referenzen auf Objekte
• Mit dem ==-Operator kann man zwei Referenzen auf Gleichheit testen
oder abfragen, ob eine Referenz leer ist:
Girokonto k1 = new Girokonto();
Girokonto k;
...
Girokonto k2 = k1;
...
if (k1 == k2)
System.out.println("k1 = k2");
...
if (k == null)
System.out.println("k = null");
© Klaus Hinrichs
Informatik I – Java
5-54
Garbage Collection
• Ist die letzte Referenz auf ein Objekt verschwunden, wird das Objekt
der Garbage Collection zugeführt ! es sind keine free- oder deleteMethoden nötig!
• Dies funktioniert auch, falls sich Objekte gegenseitig noch zyklisch
referenzieren!
• Mit
System.gc();
wird eine Empfehlung an die Garbage Collection ausgegeben, aktiv
zu werden, in der Regel ist dies aber nicht nötig.
© Klaus Hinrichs
Informatik I – Java
5-55
Klassenattribute
• Attribute und Methoden gehören zu Objekten (also Instanzen) einer
Klasse.
• Aber: es gibt Klassenattribute und Klassenmethoden, die nicht zu
Instanzen (also Objekten) gehören, sondern zu den Klassen selbst.
• Attribute, die für jedes Objekt neue Instanzen bilden, heißen
Instanzvariablen (Standardfall).
• Werden Attribute mit static gekennzeichnet, handelt es sich um
Klassenvariablen, die für die gesamte Klasse nur eine Instanz
besitzen.
• Klassenvariablen existieren auch ohne die Existenz eines Objektes.
Auf sie kann durch
Klassenname.Attributname
zugegriffen werden.
© Klaus Hinrichs
Informatik I – Java
5-56
Klassenmethoden
• Methoden, die ausschließlich auf Klassenvariablen zurückgreifen,
dürfen mit static gekennzeichnet werden, sie heißen
Klassenmethoden. Klassenmethoden dürfen auch nur Klassenmethoden benutzen.
• Klassenmethoden können auch ohne Existenz eines Objektes mit
Klassenname.Methodenname(...)
aufgerufen werden.
• Die main()-Methode ist eine Klassenmethode, da zu Beginn noch
keine Objekte erzeugt wurden
© Klaus Hinrichs
Informatik I – Java
5-57
Beispiel
class Demo {
int a;
static int b;
public static void main(String[] args) {
a = 1; // nicht erlaubt
b = 1; // erlaubt
test(); // nicht erlaubt
new Demo().test(); // erlaubt
test2(); // erlaubt
new Demo().test2(); // erlaubt
}
void test() {
a = 2; // erlaubt
b = 2; // erlaubt
}
static void test2() {
b = 3;
}
Demo d = new Demo();
d.a = 1; //erlaubt
d.b = 1; //erlaubt
Demo.a = 1; //nicht erlaubt
Demo.b = 1; //erlaubt
Demo.test(); //nicht erlaubt
Demo.test2(); //erlaubt
}
© Klaus Hinrichs
Informatik I – Java
5-58
Überladen von Methoden
• Wunsch für Methoden / Attribute: Gleiche Namen für gleiche Zwecke
– z. B. Girokonto erzeugen ohne / mit einem initialem Kontostand.
• Benutzt werden sollen Methoden mit gleichen Namen
• Problem: Wie diese Methoden auseinanderhalten?
• Idee: Unterscheide anhand Parameter-Typen, d.h. Methoden gleichen
Namens müssen sich im Typ von mindestens einem Parameter oder in
der Anzahl der Parameter unterscheiden.
zahle(int betrag);
zahle(int betrag, String verwendungszweck);
• Unterschiedliche Methoden müssen sich im Methodennamen oder in
der Übergabeparameterliste (oder in beidem) unterscheiden.
• Hat eine Klasse mehrere Methoden mit identischem Namen, so nennt
man diese Methode überladen.
• In unterschiedlichen Klassen dürfen auch Methoden mit identischem
Namen und identischen Übergabeparameterlisten deklariert werden.
© Klaus Hinrichs
Informatik I – Java
5-59
Überdecken von Attributen
• Verwenden von Variablen mit bereits benutzten Namen
• Zugreifen auf überdeckte Attribute über this
public class Girokonto {
private int kontostand; // in Pfennigen gerechnet
…
public void setzeKontostand(int kontostand) {
this.kontostand = kontostand;
}
…
}
• Variablendeklarationen in Methoden überdecken die Attribute der Klasse.
• Die Attribute sind nur überdeckt, nicht überschrieben.
• Auf Attribute der Klasse kann dann über das Schlüsselwort this bzw.
den Klassennamen zugegriffen werden.
• this ist eine Referenz auf das zur Methode zugehörende Objekt.
© Klaus Hinrichs
Informatik I – Java
5-60
Zusammenspiel zwischen Objekten
• In einem OO-System kooperieren Objekte, um
gemeinsam eine Aufgabe zu lösen.
• Jede Klasse kann etwas besonders gut (Spezialist)
– z. B. Klasse "Girokonto" für Umgang mit Girokonten
• Beim Erstellen eines OO-Systems müssen Spezialisten ausgemacht
werden
– z. B. Erweiterung um Währungsrechnen
© Klaus Hinrichs
Informatik I – Java
5-61
Übung: Zusammenspiel von Objekten ...
Lernziele
• Zusammenspiel mehrerer Objekte, Überladen von Namen
• Weg von Anforderungstext zu einer neuen Klasse
• Ändern einer bestehenden Klasse
Aufgabe
• Entwerfen und implementieren Sie eine Klasse
Waehrungsrechner für das Umrechnen:
100 EuroCent ~ 200 Pfennige
- Überlegen Sie, ob diese Klasse Attribute besitzen muß?
Welche könnte sie besitzen?
- Ergänzen Sie zwei Methoden
int konvInPfennig(int eurocent)
int konvInEuroCent(int pfennige)
© Klaus Hinrichs
Informatik I – Java
! Fortsetzung
5-62
Übung: Zusammenspiel von Objekten
• Die Klasse Girokonto soll angepaßt werden:
– Einem Girokonto-Objekt soll beim Erzeugen stets ein
"individueller" Währungsrechner übergeben werden können, der
für Konvertierungen benutzt wird.
– Verstecken Sie nach außen, daß der Kontostand intern stets in
EuroCent gespeichert und jede andere Währung konvertiert wird
(Information-Hiding).
© Klaus Hinrichs
Informatik I – Java
5-63
Übung: Zusammenspiel von Objekten
public class Waehrungsrechner {
private int euroFaktor;
public Waehrungsrechner(){
euroFaktor = 2;
}
public int konvInEuroCent(int pfennige) {
int euroCent = pfennige / euroFaktor;
return (euroCent);
}
public int konvInPfennig(int euroCent) {
int pfennige = euroCent * euroFaktor;
return (pfennige);
}
}
public class Girokonto {
private int kontostand = 0;
private Waehrungsrechner wr;
public Girokonto(Waehrungsrechner wr) {
this.wr = wr;
}
© Klaus Hinrichs
Informatik I – Java
! Fortsetzung
5-64
Übung: Änderungen in "Girokonto"
public Girokonto(Waehrungsrechner wr,
int kontostandPfennige) {
this.wr = wr;
// Umrechnen des Betrags in EuroCent:
int euroCent = wr.konvInEuroCent(kontostandPfennige);
this.kontostand = euroCent; // Kontostand aktualisieren
}
public void zahle(int pfennige) {
// Umrechnen des Betrags in EuroCent:
int euroCent = wr.konvInEuroCent(pfennige);
// Kontostand aktualisieren:
kontostand = kontostand + euroCent;
}
public int holeKontostand() {
// Umrechnen des aktuellen Kontostandes in Pfennige:
int pfennige = wr.konvInPfennig(kontostand);
return (pfennige);
}
}
© Klaus Hinrichs
Informatik I – Java
5-65
5.4.3 Operatoren, Ausdrücke, Zuweisungen
• Ausdrücke sind mehrere durch Operatoren und Klammern verknüpfte
Variablen oder Literale
Beispiel:
5 * a + 7 * (3 - b)
ist ein (in diesem Fall arithmetischer) Ausdruck.
• Ausdrücke haben Ergebnisse eines bestimmten Typs, dieses Ergebnis
kann einer Variablen zugewiesen werden.
Beispiel:
c = 5 * a + 7 * (3 - b);
© Klaus Hinrichs
Informatik I – Java
5-66
Arithmetische Operatoren …
• Arithmetische Operatoren: Bildung arithmetischer Ausdrücke
• Arithmetische Operatoren in Java:
– Addition + und Subtraktion –
– Multiplikation * und Division /
– Restbildung ("modulo") %
• Zusätzlich:
– einstellige Operatoren
– Inkrement- und Dekrement-Operatoren mit Nebeneffekten
Informatik I – Java
© Klaus Hinrichs
5-67
… Arithmetische Operatoren
Operator Bezeichnung
Bedeutung
+a ist synonym mit a
+
Positives Vorzeichen
-
Negatives Vorzeichen -a kehrt das Vorzeichen um
+
Summe
a + b ergibt die Summe von a und b
-
Differenz
a - b ergibt die Differenz von a und b
*
Produkt
a * b ergibt das Produkt von a und b
/
Quotient
a / b ergibt den Quotienten von a und b
%
Rest
a % b ergibt den bei Division von a und
b entstehenden Rest
++
Präinkrement
++a ergibt a + 1 und erhöht a um 1
++
Postinkrement
a++ ergibt a und erhöht a um 1
--
Prädekrement
--a ergibt a - 1 und erniedrigt a um 1
--
Postdekrement
a-- ergibt a und erniedrigt a um 1
© Klaus Hinrichs
Informatik I – Java
5-68
Postfix- und Präfix-Increment und Decrement
• Inkrement- und Dekrementoperatoren erhöhen, bzw. erniedrigen eine
Variable um 1, der Wert der Variable wird zurückgegeben.
• ++ ist der Inkrement- und -- der Dekrementoperator.
• Steht der Operator vor der Variablen (Präfix), so wird die Variable
zuerst erhöht (bzw. erniedrigt) und dann das Ergebnis zurückgegeben.
int a = 5;
int b = ++a; gleichbedeutend mit
a = a + 1; b = a;
Ergebnis: a == 6
b == 6
• Steht der Operator hinter der Variablen (Postfix), so wird zuerst das Ergebnis der Variablen zurückgegeben, bevor sie erhöht (bzw. erniedrigt)
wird.
int a = 5;
int b = a++; gleichbedeutend mit
b = a; a = a + 1;
Ergebnis: a == 6
b == 5
© Klaus Hinrichs
Informatik I – Java
5-69
Arithmetische Operatoren + - * / %
• Arithmetische Operatoren sind Infix-Operatoren
• Es gibt Addition +, Subtraktion -, Multiplikation *, Division / und
Modulo-Division %
• Modulo-Division bedeutet Divisionsrest, also
11 / 3 = 3, Rest 2, damit ist 11 % 3 gleich 2
• Arithmetische Operatoren lassen sich (auch in gemischter Form) auf
Variablen und Ausdrücke der Typen char, byte, int, long,
float und double anwenden.
• Divisionen durch Null sind nur für die Typen float und double
direkt erlaubt, bei char, byte, int und long wird eine Exception
geworfen (später ausführlicher).
© Klaus Hinrichs
Informatik I – Java
5-70
Ergebnistypen bei arithmetischen Operatoren …
+ - *
/ %
char
byte
short
int
long
float
double
char
int
int
int
int
long
float
double
byte
int
int
int
int
long
float
double
short
int
int
int
int
long
float
double
int
int
int
int
int
long
float
double
long
long
long
long
long
long
float
double
float
float
float
float
float
float
float
double
double double double double double double double double
© Klaus Hinrichs
Informatik I – Java
5-71
… Ergebnistypen bei arithmetischen Operatoren
• Beispiel:
public class Test {
public static void main(String[] args){
short a, b, c; // Deklaration
int d;
a = 7; // Initialisierung
b = 8;
c = a + b; // Zuweisung unzulässig
d = a + b; // Zuweisung zulässig
}
} // class Test
Fehlermeldung zur Compilezeit:
Test.java:7: possible loss of precision
found
: int
required: short
c = a + b;
^
1 error
© Klaus Hinrichs
Informatik I – Java
5-72
Implizite Typkonvertierung
• Bei einer Zuweisung muß der Ergebnistyp des Ausdrucks mit dem der
Variablen übereinstimmen, es sei denn, implizite Typkonvertierungen
sind erlaubt.
• Implizite Typkonvertierungen sind in der Regel in Richtung
"umfassenderer" Typen erlaubt:
byte
short
int
long
float
double
char
• Hinweis: char nach short wäre prinzipiell verlustfrei möglich, ist aber
dennoch unzulässig!
• Achtung: Wandlung von long nach float eventuell verlustbehaftet!
double a; // Deklarationen und Initialisierungen
double b = 10.0;
int c = 10;
a = c; // Zuweisung erlaubt
c = b; // Zuweisung nicht erlaubt
© Klaus Hinrichs
Informatik I – Java
5-73
Explizite Typkonvertierung (Cast) …
• Explizite Typkonvertierungen sind durch Cast (typ) möglich.
• Beispiel:
double b = 10.0;
int c;
c = (int) b; // Zuweisung erlaubt, da Typ gewandelt
• Typkonvertierungen sind in der Regel verlustbehaftet!
• Bei Verlusten weder Fehlermeldungen noch Warnungen zur Laufzeit!
• Beispiel: Typkonvertierung von short nach byte (hier ohne Verlust)
0000000000110001 16 Bit, Wert entspricht 49
00110001
8 Bit, Wert entspricht 49
1111111111110001 16 Bit, Wert entspricht -15
11110001
© Klaus Hinrichs
8 Bit, Wert entspricht -15
Informatik I – Java
5-74
… Explizite Typkonvertierung (Cast)
• Beispiel: Typwandlung von short nach byte (hier mit Verlust)
0000001000000010
16 Bit, Wert entspricht 514
00000010
8 Bit, Wert entspricht 2
Programm:
short a = 514;
// Typwandlung von short nach byte
byte b = (byte) a;
System.out.println(b);
Ausgabe:
2
Informatik I – Java
© Klaus Hinrichs
5-75
Vergleichsoperatoren …
• Vergleichen von Ausdrücken
• Ergebnistyp stets boolean
• In Java:
Operator Bezeichnung Bedeutung
==
gleich
a == b gibt true, wenn a gleich b ist. Im Falle von
Referenztypen ist der Rückgabewert true, wenn a
und b auf dasselbe Objekt zeigen.
!=
ungleich
a != b gibt true, wenn a ungleich b ist. Im Falle
von Referenztypen ist der Rückgabewert true,
wenn a und b auf unterschiedliche Objekte zeigen.
>
größer
a > b gibt true, wenn a größer b ist.
<
kleiner
a < b gibt true, wenn a kleiner b ist.
>=
größer gleich
a >= b gibt true, wenn a größer oder gleich b ist.
<=
kleiner gleich
a <= b gibt true, wenn a kleiner oder gleich b ist.
© Klaus Hinrichs
Informatik I – Java
5-76
… Vergleichsoperatoren
• Achtung: Gleichheitstest == nicht mit Zuweisung = verwechseln!
• Vergleich nicht für String geeignet!
• Beispiel:
int x = 3, y = 4, z = 7;
bool b = (x + y == z);
System.out.println(b);
Ausgabe:
true
© Klaus Hinrichs
Informatik I – Java
5-77
Zuweisungsoperatoren …
• Setzen des Wertes einer Variablen
•
= ist der Operator für die Standardzuweisung
• Es gibt viele Zuweisungen mit Nebeneffekten:
+= , -= , *= , /= , %= , ^= , &= , |= , <<= , >>= und >>>
a += b; gleichbedeutend mit a = a + b;
a -= b; gleichbedeutend mit a = a - b;
a *= b; gleichbedeutend mit a = a * b;
• Beispiel:
int a = 3, b = 5;
a += b;
System.out.println(a);
Ausgabe:
8
© Klaus Hinrichs
Informatik I – Java
5-78
… Zuweisungsoperatoren
Operator Bezeichnung
Bedeutung
=
Einfache Zuweisung
a = b weist a den Wert von b zu und liefert b als
Rückgabewert.
+=
Additionszuweisung
a += b weist a den Wert von a + b zu und liefert a
+ b als Rückgabewert.
-=
Subtraktionszuweisung
a -= b weist a den Wert von a - b zu und liefert a
- b als Rückgabewert.
*=
Mutiplikationszuweisung
a *= b weist a den Wert von a * b zu und liefert a
* b als Rückgabewert.
/=
Divisionszuweisung
a /= b weist a den Wert von a / b zu und liefert a
/ b als Rückgabewert.
%=
Modulozuweisung
a %= b weist a den Wert von a % b zu und liefert a
% b als Rückgabewert.
&=
UND-Zuweisung
a &= b weist a den Wert von a & b zu und liefert a
& b als Rückgabewert.
|=
ODER-Zuweisung
a |= b weist a den Wert von a | b zu und liefert a
| b als Rückgabewert.
^=
EXKLUSIV-ODER-Zuweisung a ^= b weist a den Wert von a ^ b zu und liefert a
© Klaus Hinrichs
^ b als Rückgabewert.
Informatik I – Java
5-79
Logische Operatoren …
• Vergleichen boolescher Werte in Java:
– mit Short-Circuit-Evaluation (SCE) (Kurzschluß-Auswertung !
sequentielles oder konditionales " bzw. #)
UND ("): &&
ODER (#): ||
– ohne Short-Circuit-Evalutation
UND ("): &
ODER (#): |
– Zusätzlich:
logisches NICHT (¬): !
EXKLUSIV-ODER: ^
© Klaus Hinrichs
Informatik I – Java
5-80
… Logische Operatoren
Operator Bezeichnung
!
Bedeutung
Logisches NICHT !a ergibt false, wenn a den Wert true hat, und true, wenn
a den Wert false hat.
UND mit SCE
a && b ergibt true, wenn sowohl a als auch b den Wert true
haben, ansonsten false. Hat a bereits den Wert false, so
wird false zurückgegeben und b nicht mehr ausgewertet.
&
UND ohne SCE
a & b ergibt true, wenn sowohl a als auch b den Wert true
haben, ansonsten false. Beide Teilausdrücke werden
ausgewertet.
||
ODER mit SCE
a || b ergibt true, wenn mindestens einer der beiden
Ausdrücke a oder b den Wert true hat, ansonsten false. Hat
a bereits den Wert true, so wird true zurückgegeben und b
nicht mehr ausgewertet.
|
ODER ohne SCE
a | b ergibt true, wenn mindestens einer der beiden
Ausdrücke a oder b den Wert true hat, ansonsten false.
Beide Teilausdrücke werden ausgewertet.
^
EXKLUSIVODER
a ^ b ergibt true, wenn a und b unterschiedliche Werte
haben, ansonsten false
&&
Informatik I – Java
© Klaus Hinrichs
5-81
Bitweise AND, OR, XOR …
• Vergleich der einzelnen Bits zweier ganzer Zahlen
• Für alle ganzzahligen primitiven Datentypen
• Es gibt "bitweise UND" bzw. AND (&), "bitweise inklusiv ODER" bzw.
OR (|) und "bitweise exclusiv ODER" bzw. XOR (^)
© Klaus Hinrichs
& 0 1
| 0 1
^ 0 1
0 0 0
0 0 1
0 0 1
1 0 1
1 1 1
1 1 0
Informatik I – Java
5-82
… Bitweise AND, OR, XOR
• Für jede Position der Bitdarstellung der beiden Eingabezahlen wird ein
Bit berechnet und in der Bitdarstellung der Ergebniszahl an derselben
Position abgelegt.
Beispiel:
00000011
00001001
========
entspricht 3
entspricht 9
AND:
00000001
entspricht 1
OR:
00001011
entspricht 11
XOR:
00001010
entspricht 10
Programm:
byte a = 3, b = 9;
System.out.println(a & b);
System.out.println(a | b);
System.out.println(a ^ b);
© Klaus Hinrichs
Ausgabe:
1
11
10
Informatik I – Java
5-83
Verschiebeoperatoren …
• Durch Verschiebeoperatoren können Bitdarstellungen von Ganzzahldatentypen nach links bzw. rechts verschoben werden.
• Links vom Operator steht der zu verschiebende Wert und rechts die
Anzahl der Bits, um die verschoben werden soll.
•
<< ist der Links-Shift-Operator
•
>> und >>> sind Rechts-Shift-Operatoren.
• Bei << und >>> wird jeweils die Null nachgeschoben, bei >> das
Vorzeichenbit.
•
a << n entspricht einer Multiplikation mit 2n und a >> n entspricht
einer Division durch 2n ! Geschwindigkeitsvorteile!
© Klaus Hinrichs
Informatik I – Java
5-84
… Verschiebeoperatoren
• Beispiel:
a
a << 1
a >> 1
a >>> 1
~a
00000000000000000000000000000011
00000000000000000000000000000110
00000000000000000000000000000001
00000000000000000000000000000001
11111111111111111111111111111100
3
6
1
1
-4
a
a << 1
a >> 1
a >>> 1
~a
11111111111111111111111111111110
11111111111111111111111111111100
11111111111111111111111111111111
01111111111111111111111111111111
00000000000000000000000000000001
-2
-4
-1
2147483647
1
© Klaus Hinrichs
Informatik I – Java
5-85
String-Konkatenation
• Der Operator + kann verwendet werden, um zwei Objekte der Klasse
String zu verknüpfen.
• Ist nur einer der Operanden ein Objekt der Klasse String, und ein
anderer ein primitiver Datentyp, wird letzterer nach String
gewandelt.
• Beispiel:
int alter = 27;
System.out.println("Alter: " + alter + " Jahre");
Ausgabe:
Alter: 27 Jahre
© Klaus Hinrichs
Informatik I – Java
5-86
Unäre Operatoren
• Unäre Operatoren werden immer vor einen Ausdruck gestellt.
• Es gibt Plus- und Minusvorzeichen (+) und (-), sowie logische (!) und
bitweise (~) Verneinung.
• Vorzeichen und bitweise Verneinung werden für Ganzzahldatentypen
verwendet, die logische Verneinung für den Datentyp boolean.
© Klaus Hinrichs
Informatik I – Java
5-87
Konditionaler Operator ? …
• Mit bedingten Ausdrücken der Form
Bool-Ausdruck ? Ausdruck1 : Ausdruck2
lassen sich Alternativen in Ausdrücken beschreiben.
•
Bool-Ausdruck muß einen Wert vom Typ boolean ergeben,
Ausdruck1 und Ausdruck2 sind zwei Ausdrücke mit Wert vom
gleichen Typ und müssen zuweisungskompatibel sein.
• Ist Bool-Ausdruck gleich true, so wird Ausdruck1 ausgewertet
und der Wert zurückgegeben, sonst Ausdruck2.
© Klaus Hinrichs
Informatik I – Java
5-88
… Konditionaler Operator ?
• Beispiel 1:
int alter = 17;
System.out.println(alter >= 18 ? "alt" : "jung");
Ausgabe:
jung
• Beispiel 2:
int alter = 18;
double beitrag = ((alter >= 18) ? 200 : 100);
System.out.println("Beitrag: " + beitrag);
Ausgabe:
Beitrag: 200
© Klaus Hinrichs
Informatik I – Java
5-89
Operator-Prioritäten
• Die Standard-Richtung für die Auswertung von Operatoren ist von
links nach rechts.
• Zuweisungsoperatoren werden von rechts nach links ausgewertet.
• Operatoren unterliegen einer Prioritätenhierarchie, analog der Punktvor Strich-Regel $ der Ausdruck 5 + 3 * 3 + 1 repräsentiert den
Wert 15, da die Multiplikation höhere Priorität hat.
• Operatoren mit höchster Priorität werden zuerst ausgewertet.
• Durch Klammerung mit runden Klammern ( und ) kann die
vorgegebene Hierarchie überwunden werden.
© Klaus Hinrichs
Informatik I – Java
5-90
Operator-Prioritäten
Priorität
Kategorie
Operatoren
0
Zuweisung
1
2
3
4
5
6
7
8
9
10
11
12
Bedingungsoperator
logisches Oder
logisches Und
bitweise Oder
bitweise exkl. Oder
bitweise Und
Vergleichsop.
Vergleichsop.
Verschiebeop.
additive Operatoren
multiplikative Op.
Erzeugungs- oder
Typumwandlungsop.
unäre Operatoren
Postfix-Operatoren
= += -= *= /=
%= ^= &= |=
<<= >>= >>>=
? :
||
&&
|
^
&
== !=
< > <= >=
instanceof
<< >> >>>
+ –
* / %
new
(type)expr
++expr --expr
+expr -expr ~ !
[] . expr++ expr--
13
14
© Klaus Hinrichs
Informatik I – Java
5-91
Operator-Prioritäten: Beispiele …
int a, b = 2;
a = b << 1 + 2;
Addition hat höhere Priorität als Verschiebeoperatoren.
Es wird daher zunächst 1 + 2 ausgewertet und der Wert von b dann
um 3 Bits nach links verschoben, man erhält also 16. Dieser Wert wird
dann der Variablen a zugewiesen, denn der Zuweisungsoperator hat
die niedrigste Priorität.
int a, b = 2;
a = (b << 1) + 2;
Auf Grund der Klammerung wird die Verschiebung zuerst durchgeführt.
b um ein Bit nach links verschoben ergibt 4. Dann wird 2 aufaddiert und
das Ergebnis 6 der Variablen a zugewiesen.
© Klaus Hinrichs
Informatik I – Java
5-92
… Operator-Prioritäten: Beispiele
int a = 5, b;
a += b = 8;
Auswertungsreihenfolge von rechts nach links
Zunächst wird b die Zahl 8 zugewiesen, dann wird der neue Wert
von b auf a aufaddiert, a erhält also den Wert 13.
(a += b) = 8;
Fehler: Auswertreihenfolge läßt sich nicht verändern, denn
Ausdrücke dürfen nie links von einer Zuweisung stehen.
© Klaus Hinrichs
Informatik I – Java
5-93
5.4.4 Anweisungen
• Programme bestehen aus Klassen.
• Eine der Klassen eines Programms hat eine Methode namens main, mit
der die Programmausführung beginnt.
• Danach werden in der Regel Objekte erzeugt, die dann für bestimmte
Aufgaben zuständig sind.
• Die Kommunikation zwischen den Objekten erfolgt über den Aufruf von
Methoden / das Versenden von Nachrichten.
• Was innerhalb einer Methode passiert, wird durch Anweisungen festgelegt. Bereits bekannte Grundbausteine der Anweisungen:
– Literale und Variable
– Operatoren
• Algorithmus (also die Verarbeitungsvorschrift), der durch eine Methode
realisiert wird, wird durch eine Menge von Anweisungen beschrieben.
• Die Arten von Anweisungen, die hierfür verwendet werden, diskutieren
wir im folgenden.
• Danach kennen wir dann alle Grundbestandteile von Java-Programmen!
© Klaus Hinrichs
Informatik I – Java
5-94
Anweisungen …
• Anweisungen (außer Blöcken) werden durch ; voneinander getrennt.
• Blöcke sind Sequenzen von Anweisungen, in der Regel geklammert mit
{}. Blöcke werden nicht durch ; voneinander getrennt.
{
konto.zahle(+100);
konto.zahle(+30);
{
konto.zahle(-20);
Anweisung1;
}
Anweisung2;
...
}
© Klaus Hinrichs
Informatik I – Java
5-95
… Anweisungen
• Deklarationen bzw. Initialisierungen innerhalb von Blöcken sind nur
innerhalb dieser gültig.
• Auch die bereits bekannten
- Zuweisungen
- Deklarationen und Initialisierungen
sind Anweisungen.
• "Einfache" Anweisungen werden der Reihenfolge nach abgearbeitet.
• Blöcke, Bedingungen, Schleifen und Sprünge sind Anweisungen, die
den Kontrollfluß beeinflussen und komplexere Strukturen als Ausdrücke
beschreiben.
© Klaus Hinrichs
Informatik I – Java
5-96
Sichtbarkeit in Blöcken
• Da Deklarationen außerhalb eines Blocks nicht bekannt sind, stellt sich
bei Attributen und Variablen, die in mehreren Blöcken namensgleich
deklariert werden, die Frage, auf welches Attribut durch einen
Attributnamen Bezug genommen wird.
• Der Zugriff auf die "falschen" Attribute ist eine häufige Fehlerursache.
• Generelle Regel für Sichtbarkeit:
– Suche zunächst im aktuellen (also inneren) Block nach dem Attribut,
– wird es dort nicht gefunden, überprüfe schrittweise umgebende
Blöcke, bis ein entsprechend benanntes Attribut gefunden wird.
• Besonders verwirrend kann dabei sein, daß Attribute und Variable erst
ab der Deklarationsanweisung bekannt sind.
© Klaus Hinrichs
Informatik I – Java
5-97
Variablen in Blöcken
• Im Block deklarierte Variablen sind nur im Block sichtbar:
public void zahle(int betrag) {
int alterKontostand = kontostand;
{ // hier ist alterKontostand sichtbar
int neuerKontostand = kontostand + 50000;
// ab hier ist auch neuerKontostand sichtbar
…
System.out.println(neuerKontostand);
}
// neuerKontostand unsichtbar
// alterKontostand sichtbar
int neuerKontostand = 1;
// ab hier neue Variable neuerKontostand sichtbar
kontostand = kontostand + betrag;
}
© Klaus Hinrichs
Informatik I – Java
5-98
if-Anweisung …
• Bedingte Verzweigungen dienen zur Auswahl aus zwei Alternativen
if (Bool-Ausdruck)
Anweisung1;
else
Anweisung2;
•
Bool-Ausdruck muß einen Wert vom Typ boolean ergeben.
Anweisung1 wird ausgeführt, falls Bool-Ausdruck den Wert
true hat, sonst wird Anweisung2 ausgeführt.
if (kontostand < 0)
System.out.println("Konto überzogen");
else
System.out.println("Geld vorhanden");
• Der Teil else Anweisung2 ist optional. Fehlt dieser Teil und
liefert Ausdruck false, so wird die if-Anweisung ohne weitere
Ausführung verlassen.
© Klaus Hinrichs
Informatik I – Java
5-99
… if-Anweisung …
• Unterschied zum bedingten Ausdruck
Bool-Ausdruck ? Ausdruck1 : Ausdruck2
if-else liefert keinen Wert zurück!
• Blöcke sind Anweisungen ! mehrere Anweisungen lassen sich
innerhalb des if- oder else-Teils gruppieren:
if (landeswährung == DM) {
neuerBetrag = betrag * 1.96;
System.out.println("Guthaben: " + neuerBetrag
+ " DM");
} else
System.out.println("Guthaben: " + betrag
+ " Euro");
© Klaus Hinrichs
Informatik I – Java
5-100
… if-Anweisung
• Bedingte Verzweigungen sind selbst auch Anweisungen $
Schachtelung von if-Abfragen möglich:
if (beruf == schüler)
System.out.println(" Schülertarif");
else
if (beruf == rentner)
System.out.println(" Rentnertarif");
else
System.out.println(" Normaltarif");
© Klaus Hinrichs
Informatik I – Java
5-101
switch-Anweisung …
•
•
•
•
•
switch ( Ausdruck ){
case Konstante_1: Anweisungsfolge_1;
case Konstante_2: Anweisungsfolge_2;
...
default: Anweisungsfolge_n;
}
Ausdruck ergibt einen Wert vom Typ byte, short, int oder char
Konstante_i ist Konstante vom gleichen Typ wie Ausdruck
Anweisungsfolge_i ist Folge von Anweisungen, die durch ;
voneinander getrennt sind.
Zuerst wird Ausdruck ausgewertet. Dann werden alle Anweisungen ab
der ersten Konstante, welche gleich dem Wert des Ausdrucks ist,
abgearbeitet.
Anweisungsfolge_n hinter default: wird auch abgearbeitet, falls
keine Konstante gleich dem Wert von Ausdruck ist. Die default-Zeile ist
optional.
© Klaus Hinrichs
Informatik I – Java
5-102
... switch-Anweisung ...
• Kommt die Anweisung break; in einer abzuarbeitenden Anweisungsfolge vor, so wird der gesamte von switch gefolgte Block verlassen.
int zensur = 2;
switch (zensur) {
case 1:
System.out.println(" sehr gut");
break;
case 2:
System.out.println(" gut");
break;
...
default:
System.out.println("keine Zensur!");
}
© Klaus Hinrichs
Informatik I – Java
5-103
... switch-Anweisung ...
int month = 2;
int year = 2000;
int numDays = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numDays = 31;
break;
case 4:
case 6:
case 9:
case 11:
numDays = 30;
break;
© Klaus Hinrichs
! Fortsetzung
Informatik I – Java
5-104
... switch-Anweisung …
case 2:
if ( ((year % 4 == 0) && !(year % 100 == 0))
|| (year % 400 == 0) )
numDays = 29;
else
numDays = 28;
break;
}
System.out.println("Number of Days = " + numDays);
© Klaus Hinrichs
Informatik I – Java
5-105
... switch-Anweisung …
class Toomany {
static void howMany(int k) {
switch (k) {
case 1: System.out.print("one ");
case 2: System.out.print("too ");
case 3: System.out.print("many ");
}
}
public static void main(String[] args) {
howMany(3);
System.out.println();
howMany(2);
System.out.println();
howMany(1);
System.out.println();
}
}
Ausgabe:
many
too many
one too many
© Klaus Hinrichs
Informatik I – Java
5-106
... switch-Anweisung
class Twomany {
static void howMany(int k) {
switch (k) {
case 1: System.out.println("one ");
break;
// exit the switch
case 2: System.out.println("two ");
break;
// exit the switch
case 3: System.out.println("many ");
break;
// not needed, but good style
}
}
public static void main(String[] args) {
howMany(1);
howMany(2);
howMany(3);
}
}
Ausgabe:
one
two
many
© Klaus Hinrichs
Informatik I – Java
5-107
Schleifen
• Schleifen dienen dazu, die gleiche Anweisung mehrfach durchlaufen
zu können.
• Diese Anweisung kann auch ein Block sein, also mehrere
Anweisungen gruppieren.
• Es gibt Abbruch- bzw. Laufbedingungen für Schleifen.
• 3 Schleifentypen:
– while-Schleife,
– do-while -Schleife,
– for-Schleife
© Klaus Hinrichs
Informatik I – Java
5-108
while-Schleife
while (Bool-Ausdruck)
Anweisung;
• Die Laufbedingung Bool-Ausdruck ist vom Typ boolean.
• Zunächst wird Bool-Ausdruck ausgewertet. Falls Bool-Ausdruck
den Wert true liefert, wird Anweisung abgearbeitet. Dies wiederholt
sich solange, bis Bool-Ausdruck den Wert false liefert.
• Test erfolgt vor Ausführung der Anweisung!
int a = 0;
while (a < 100) {
System.out.print(a + " ");
a = a + 10;
};
int a = 100;
while (a < 100) {
…
…
};
Ausgabe: 0 10 20 … 90
keine Ausgabe
© Klaus Hinrichs
Informatik I – Java
5-109
do-while-Schleife
do
Anweisung
while (Bool-Ausdruck);
• Test erfolgt nach Ausführung der Anweisung, also mindestens ein
Durchlauf!
int a = 0;
int a = 100;
do {
do {
System.out.print(a + " ");
…
a = a + 10;
…
} while (a < 100);
} while (a < 100);
Ausgabe:
0 10 20 … 90
© Klaus Hinrichs
Ausgabe:
100
Informatik I – Java
5-110
for-Schleife …
for (Init; Test; Update)
Anweisung;
•
Init ist eine Liste von Ausdrücken, die durch Kommata getrennt sind
und als Initialisierung vor Eintritt in die Schleife abgearbeitet (nur einmal!) werden. Typischerweise werden hier Zählervariablen vereinbart.
•
Test ist die Laufbedingung und muß daher einen Wert vom Typ
boolean liefern. Ist das Ergebnis false, wird abgebrochen,
ansonsten wird als nächstes mit Anweisung der Schleifenrumpf
abgearbeitet.
•
Update ist eine Liste von Anweisungen, die durch Kommata getrennt
sind und immer nach Ausführung des Schleifenrumpfes (Anweisung)
ausgeführt werden.
• Nach der Auswertung von Test wird die Schleife dann fortgesetzt,
wenn Test true liefert.
© Klaus Hinrichs
Informatik I – Java
5-111
… for-Schleife
• Alle Anweisungen können optional weggelassen werden:
for (;;)
;
liefert Endlosschleife!
int i;
for (i = 0; i < 3; i++)
System.out.println(i);
Ausgabe
0
1
2
© Klaus Hinrichs
Informatik I – Java
5-112
Markierte Anweisungen
• Eine Anweisung kann durch einen Namen markiert werden:
Markierung: Anweisung
• Markierung ist ein Bezeichner.
• Gewöhnlich ist Anweisung ein Block oder eine Schleife.
• Mit break Markierung wird Anweisung abgebrochen und mit dem
unmittelbar auf Anweisung Folgenden fortgefahren.
• continue Markierung wird nur bei Schleifen benutzt und bewirkt
die Beendigung der gegenwärtigen Iteration des Schleifenrumpfes.
• Markierung ist nur innerhalb der markierten Anweisung (Block,
Schleife o. ä.) sichtbar.
• Innerhalb von Bedingungs- und Zählschleifen kann break und
continue ohne Markierung verwendet werden. Hier wird die innerste
umgebende Schleife als markiert betrachtet.
• Sprunganweisungen sind in der Regel ein Anzeichen schlechter
Strukturierung, sie sollten vermieden werden.
• Es gibt keine allgemeine Sprunganweisung (goto)!
© Klaus Hinrichs
Informatik I – Java
5-113
Markierte Anweisungen
marke1: for (i = 1; i < 6; i++) {
marke2: for (j = 1; j < 4; j++) {
System.out.println(i +"/"+ j);
if (i == 2)
break marke2; // Äquivalent zu break;
if (i == 4)
Ausgabe:
1 / 1
continue marke1;
1 / 2
}
1 / 3
System.out.println("=====");
=====
2 / 1
}
=====
3 / 1
3 / 2
3 / 3
=====
4 / 1
5 / 1
5 / 2
5 / 3
=====
© Klaus Hinrichs
Informatik I – Java
5-114
Sichtbarkeit
{
a
test
...
int a;
test: for (a = 0; a < 100; a++) {
int b;
for (int c = 0; c < a; c++) {
System.out.println(a * c);
}
}
int d = 7;
System.out.println(a * d);
b c
d
}
• x ist sichtbar in Block
© Klaus Hinrichs
Informatik I – Java
5-115