Java Schulung Syntax

Java Schulung
Objektorientierte Programmierung in Java
Teil II: Java Grundlagen und Syntax
Prof. Dr. Nikolaus Wulff
Agenda: Java Grundlagen
•
•
•
•
•
•
•
•
Java Syntax
Java Datentypen
Kontrollstrukturen
Klassen und Objekte
Überschreiben/Überladen von Methoden
Sichtbarkeit
Behandlung von Ausnahmen (Exceptions)
Die wichtigsten Java Pakete
Prof. Dr. Nikolaus Wulff
2
Abstrakte Datentypen
• Klassen sind die logische Erweiterung des Konzepts des ADT.
• In prozeduralen Sprachen werden ADT's durch Records (Pascal),
Structs (C), Common-Blöcke (Fortran) oder Copy-Strecken
(Cobol/PL1) realisiert.
• Dies sind jedoch lediglich reine Datencontainer.
• In der Objektorientierung werden diese ADT's um die Deklaration der
möglichen, erlaubten Manipulationen erweitert.
• Klasse ≡ Daten + Methoden
• Ein Objekt ist eine Instanz einer Klasse
– Der entsprechende Speicherplatz für die Daten ist alloziiert und die
Methoden können auf diese zugreifen.
Prof. Dr. Nikolaus Wulff
3
Kapselung
Kapselung
• Kapselung bedeutet, daß auf alle nicht exportierten Eigenschaften eines
Objekts von außen nicht direkt zugegriffen werden kann.
• Wird die konkrete Repräsentation des Zustands verborgen, spricht man
auch vom Geheimnisprinzip (Information Hiding, nach [Parnas72]).
• Kapselung heißt auch, daß die Signatur und das abstrakte Verhalten
einer Operation bekannt ist, die Implementation aber verborgen bleibt.
Nicht alle oo Programmiersprachen realisieren die
Kapselung von Zustand und Implementationen geeignet.
Prof. Dr. Nikolaus Wulff
4
Eine Klasse in Java
Blockanfang
public class Sparbuch {
public void auszahlen( float betrag )
{ ...
}
public void einzahlen( float betrag )
{ ...
}
public void berechneZinsen()
{ ...
}
}
Für jede Klasse wird in
Java eine eigene Datei
angelegt.
Beispiel: Sparbuch.java
Operationen,
(Methoden, Routinen)
private float saldo;
private float zinssatz;
Attribute
Blockende
Prof. Dr. Nikolaus Wulff
5
Hauptprogramm
• Die Virtual-Machine wird unter Angabe eines Klassennamens gestartet. In dieser
Klasse wird nach einer statischen Operation mit eine bestimmten Signatur
gesucht, nämlich: public static void main(String[] args).
• Eine solche Operation kann es auch mehrfach in unterschiedlichen Klassen
geben. Je nachdem welches main() gestartet werden soll, wird der
entsprechende Klassenname der Virtual-Maschine übergeben.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, world");
}
}
Prof. Dr. Nikolaus Wulff
6
Konstruktoren
Um dem Programmierer zu ermöglichen, die Initalisierung der
Variablen eines Objekts zu beeinflussen, gibt es in Java die
Möglichkeit, sogenannte Konstruktoren zu vereinbaren. Sie werden
automatisch aufgerufen, wenn ein Objekt erzeugt wird. Konstruktoren
sind Operationen, die den gleichen Namen wie die Klasse haben.
Einschränkungen
• Konstruktoren dürfen keinen Rückgabetyp besitzen.
"Nicht einmal" void.
• Sie können vom Programmierer nicht explizit
aufgerufen werden. Sie werden vom Compiler
automatisch eingefügt, sobald er auf eine Codezeile
trifft, in der ein neues Objekt erzeugt wird.
Prof. Dr. Nikolaus Wulff
7
Objekte erzeugen
• Objekte müssen zur Laufzeit durch einen expliziten Ausdruck erzeugt werden.
Dazu wird der Konstruktor mit dem Schlüsselwort new verwendet.
Sparbuch einUrlaubssparbuch = new Sparbuch();
Sparbuch einNotgroschen = new Sparbuch();
• Wird eine Variable mit dem Typ einer Klasse deklariert, so hat sie solange den
Initialwert null, bis ihr ein Objekt zugewiesen wird.
Sparbuch einUrlaubssparbuch;
// null
Sparbuch einNotgroschen;
// null
einUrlaubssparbuch = new Sparbuch();
einNotgroschen = einUrlaubssparbuch;
Prof. Dr. Nikolaus Wulff
8
Schlüsselworte
Beachte: case-sensitive!
abstract default
boolean do
break
double
byte
else
case
extends
catch
final
char
finally
class
float
const* for
continue goto*
if
implements
import
instanceof
int
interface
long
native
new
package
private
throw
protected
throws
public
transient
return
try
short
void
static
volatile
super
while
switch
synchronized
this
* momentan nicht genutzt
Keine Schlüsselworte: true, false, null
Neu ab JDK1.4: assert
Prof. Dr. Nikolaus Wulff
9
Java Konventionen
• Bezeichner: Neue Wörter beginnen mit Großbuchstaben. Keine
Unterstriche zur Trennung verwenden. Also nicht drucke_kunden,
sondern druckeKunden.
• Klassennamen beginnen mit einem Großbuchstaben, z.B. Girokonto.
• Operationsnamen beginnen mit einem Kleinbuchstaben, z.B. zahleEin.
• Einige Entwickler lassen Attributnamen mit einem Unterstrich beginnen,
z.B. _saldo. (Aber bitte einheitlich!)
• Nach jeder öffnenden und vor jeder schließenden geschweiften Klammer
eine neue Zeile beginnen.
• Optional: Vor jeder öffnenden geschweiften Klammer eine neue Zeile
beginnen.
• Nach jeder öffnenden geschweiften Klammer eine Einrückung
vornehmen. Vor der schließenden geschweiften Klammer diese
Einrückung wieder zurücknehmen.
• Pro Anweisung eine Zeile.
• Moderne IDE's ermöglichen automatische Formatierung.
Prof. Dr. Nikolaus Wulff
10
Java Bean Konvention
• In Java werden Attribute durch getXXX und setXXX Operationen
gelesen bzw. gesetzt.
• Arrays werden entsprechend mit getXXX(int index) und
setXXX(int index, Object val) angesprochen.
• Für boolean Attribute kann optional auch die Operation isXXX statt
getXXX verwendet werden.
• Tools (IDE's und Generatoren) sowie die Java Reflection API
verwenden diese Konvention!
• D.h. eine Klasse mit einer Eigenschaft XYZ hat eine entsprechende
– public XYZ getXYZ() Methode für den lesenden Zugriff und eine
– public void setXYZ (XYZ v) Methode für schreibenden Zugriff.
• Diese Namenskonvention ist für den Entwickler bindend
(insbesondere set und get, gibX und setzeX ist nicht konform!) .
Prof. Dr. Nikolaus Wulff
11
Elementare Typen
• Imperative und objektorientierte Programmiersprachen bieten i.d.R.
einen Satz elementarer Typen an:
• Natürliche Zahlen (Integer)
• reale Zahlen (Float oder Real)
• Zeichen (char)
• und Wahrheitswerte (boolean).
• Java verfügt über eine Reihe von elementaren Typen (basic oder
primitive types): int, short, long, float, double,
byte, boolean und char.
• Der Typ einer Variable legt fest
• die Wertemenge (z.b. int nur ganze Zahlen) und
• die zulässigen Operationen (z.B. int Addieren, Subtrahieren)
Prof. Dr. Nikolaus Wulff
12
Basisdatentypen und Literale
•
•
•
•
•
Escape Sequenzen
Wahrheitswerte (boolean):
– Konstanten: true, false
\b
/* backspace
\t
/* horizontal tab
Zeichen (char):
\n
/* line feed
– Konstanten: ´o´, ´\t´,
\f
/* form feed
´\u78ab´ (Unicode hexadezimal)
\r
/* carriage return
Zeichenketten (String):
\"
/* double quote "
– Konstanten: “Hallo“,
\'
/* simple quote '
“Hello“ + “ “ + “World\n“
\\
/* backslash \
ganze Zahlen:
– Konstanten: 47, 47890L (long), 077 (oktal), 07777L (oktal long),
0x89ab (hexadezimal), 0XC0B0L (hex long)
Fließkommazahlen:
– Konstanten: 3.141F, 6.02E23, 6.02E23F, 6.02E23D
Prof. Dr. Nikolaus Wulff
13
*/
*/
*/
*/
*/
*/
*/
*/
Die numerischen Datentypen
numerische Datentypen:
• Jede prozedurale Programmierspache bietet elementaren numerischen
Datentypen mit den zugehörigen Operationen an.
• Die Wertebereiche dieser Datentypen sind meist maschinenabhängig, was die
Übertragbarkeit von Programmen erschwert.
• In Java sind die elementaren Datentypen systemunabhängig festgelegt.
Typ
byte
short
int
long
Größe
1 Byte
2 Bytes
4 Bytes
8 Bytes
float 4 Bytes
double 8 Bytes
Prof. Dr. Nikolaus Wulff
Wertebereich
-128 bis 127
-32.768 bis 32.767
-2.147.483.648 bis 2.147.483.647
-9.223.372.036.854.775.808 bis
9.223.372.036.854.775.807
1,40239846*10-45 bis 3,40282347*1038
4,94065645841246544*10-324 bis
1,79769313486231570*10308
14
Basisdatentypen vs. Klassen (1)
•
Für einige Typen existieren sowohl Basisdatentypen als auch Klassen,
z.B. int (Basisdatentyp) und Integer (Klasse).
•
Auf den Basisdatentypen sind mathematische Operationen vordefiniert,
z.B. +, -, *, \.
• Die Klassen bieten weitere Methoden zur Manipulation an, z.B.
Integer.parseInt(“89“) zum Umwandeln einer Zeichenkette in
eine Zahl.
• Werte der Basisdatentypen sind keine Objekte (Superklasse Object)
und können daher an einigen Stellen nicht verwendet werden. Beispiele:
Vector, Hashtable.
Vector v = new Vector();
// Vektor von Objekten
v.addElement(1);
// Fehler 1 ist kein Objekt
v.addElement(new Integer(1)); // o.k.
•
Seit JDK1.5 gibt es „autboxing“ 1 wird in Integer(1) verwandelt und
addElement(1) funktioniert automatisch...
Prof. Dr. Nikolaus Wulff
15
Basisdatentypen vs. Klassen (2)
•
Literale evaluieren zu Werten von Basisdatentypen, z.B. 1 zu int.
Ausnahme: Zeichenketten werden zu Objekten der Klasse String.
•
Objekte müssen explizit angelegt werden, z.B. new Integer(1).
Prof. Dr. Nikolaus Wulff
16
Basisdatentypen vs. Klassen (3)
•
Unterschiede beim Vergleich (Wertgleichheit vs. Objektidentität):
1 == 1
•
new Integer(1) != new Integer(1)
Unterschiede bei der Zuweisung (Kopie vs.Referenz):
int a = 75;
int b = 100;
b = a;
a = 200;
// b == 75
// a != b
a
b
75
100
a
b
200
75
Integer a = new Integer(75);
Integer b = new Integer(100);
b = a; // Objektreferenz wird geändert
a.setInt(200);
// b.intValue() == 200
// a == b
a
b
75
(2)
(1)
Prof. Dr. Nikolaus Wulff
100
a
b
(3)
200
17
Operatoren
Operator Funktion, boolesche
Operator Funktion, arithmetisch
*
/
%
+
++
--
Multiplikation
Division
Modulo
Addition
Subtraktion
Inkrement
Dekrement
!
<
<=
>
>=
&&
||
• Der Gleichheitstest wird häufig mit der
Zuweisung verwechselt
saldo = 0;
saldo == 0;
saldo != 0;
Operator
==
!=
=
Funktion
Gleichheit
Ungleichheit
Zuweisung
Prof. Dr. Nikolaus Wulff
logisches NICHT (NOT)
“kleiner als”
“kleiner als oder gleich”
“größer als”
“größer als oder gleich”
logisches UND (AND)
logisches ODER (OR)
// Zuweisung
// Gleichheit
// Ungleichheit
• Die Zuweisung liefert in Java ein Ergebnis:
int i, j;
i = j = 0;
// Auswertung von rechts
// nach links
• Redundante Operatoren:
saldo++; saldo = saldo + 1;
18
Operationen mit Basisdatentypen
• Zusammenziehen von Operationen und Zuweisungen
möglich:
sum = sum + count
sum = sum + 1
sum += count
sum++
• Operationen mit Seiteneffekt:
(a != 0) &
((100 / a) > 10)
u.U. Division durch 0
• Short Circuit (&& und ||): boolscher Ausdruck wird nur
solange ausgewertet, bis das Ergebnis feststeht:
(a != 0) && ((100 / a) > 10)
Prof. Dr. Nikolaus Wulff
immer o.k.
19
Variablen und Konstanten
• Vor ihrer Verwendung müssen Variablen und Konstanten bekanntgemacht, d.h.
deklariert werden.
• Das kann an jeder beliebigen Stelle im Source-Code geschehen:
• Angabe des Typs, der die Wertemenge und die zulässigen Operationen
bestimmt,
• Nennung ihres Bezeichners.
• Vom Laufzeitsystem wird jede Variable mit einem standardisierten Initialwert
belegt. Optional kann bei der Deklaration ein Initialwert zugewiesen werden.
• Syntax in Java:
<VarDeklaration> := <Typ> <Bezeichner>
• Beispiel:
int i;
double d = 1.123;
char c = 'a';
Prof. Dr. Nikolaus Wulff
Eine Konstante wird mit dem Schlüsselwort
final deklariert. Bei der Deklaration muß der
Wert der Konstanten angegeben werden.
Beispiel:
final int i = 10;
final double pi = 3.1415; 20
final char a = 'a';
Attribute
• Ein Attribut wird in der Klasse im Anschluß an die Operationen oder vor den
Operationen deklariert (Wichtig: einheitliche Konvention im Projekt!). Dies
geschieht durch:
• Festlegung der Sichtbarkeit,
• Angabe des Typs,
• Nennung ihres Bezeichners.
• Über die Sichtbarkeit wird festgelegt, ob und wer von Außen auf die
Exemplarvariable zugreifen darf (näheres später).
• Auch die Exemplarvariablen können mit einem Initialwert versehen werden.
• Syntax in Java:
<VarDeklaration> := <Sichtbarkeit> <Typ> <Bezeichner>
• Beispiel:
private float zinssatz;
private float saldo = 0.0;
Prof. Dr. Nikolaus Wulff
21
Array
• Datentyp, der eine Menge von Elementen des gleichen Typs (Elementtyp)
repräsentiert.
• Die Anzahl der Elemente ist fest und heißt Länge des Array.
• Der Name einer Array-Variablen bezeichnet den gesamten Array.
• Ein einzelnes Array-Element wird durch eine Nummer (Index) identifiziert.
• Ein Index ist eine ganze Zahl zwischen 0 und (Länge - 1).
• Arrays sind Objekte, es gibt aber keine explizite Array-Klasse(!)
• die Größe wird bei Erzeugung des Array-Objektes zur Laufzeit festgelegt. Eine
dynamische Größenänderung ist nicht möglich.
• Die Länge des Arrays kann mit length ermittelt werden. length ist keine
Operation, sondern eine Art „Read-Only-Attribut“.
a
0
Index
Prof. Dr. Nikolaus Wulff
a[i]
i
N-1
Länge = N
22
Beispiel: Array
public class Liste {
private int[] array;
private int anzahl;
public Liste()
{
array = new int[10];
anzahl = 0;
}
public void elementHinzufügen(int e){
array[anzahl++] = e;
}
Array des Typs int
deklarieren, ohne
Angabe der Arraygröße
Erzeugen des Array-Objektes
Zuweisung auf ein
Element des Arrays
...
}
Prof. Dr. Nikolaus Wulff
23
Operationen
•
Die nach Außen sichtbare Schnittstelle eines Objektes wird durch
seine möglichen Operationen bestimmt.
• Der Aufruf einer Operation wird häufig auch Nachricht oder Botschaft
genannt.
– Beispiel: Der EventService sendet die Nachricht aktualisierePostkorb an
die Postkorb Instanz des Benutzers.
•
Manchmal werden Operationen auch (etwas künstlich) in Prozeduren
und Funktionen unterteilt.
Prof. Dr. Nikolaus Wulff
24
Deklaration von Prozeduren
Prozeduren sind verändernde bzw. manipulierende Operationen, die den Zustand des
Objektes, mit dem sie gerufen werden, verändern. Eine Operation wird in Java dadurch
als Prozedur gekennzeichnet, daß ihre Deklaration mit void eingeleitet wird.
nach Außen
sichtbar
benutzerdefinierter Bezeichner für die
Prozedur (in Java kleingeschrieben)
public void einzahlen(float betrag );
Parametername
Prozeduren liefern keinen
Rückgabewert
formaler Parameter vom Typ float
Werden mehrere Parameter angegeben, muß für jeden Parameter der Typ
mitgegeben werden. Die Parameter werden durch Komma getrennt.
public void setzeKonditionen(float habenzins, float sollzins);
Prof. Dr. Nikolaus Wulff
25
Deklaration von Funktionen
Funktionen sind sondierende Operationen, die den Zustand des Objektes, mit dem sie
gerufen werden, nicht verändern dürfen. Der Funktionsname steht - im Unterschied zu
einem Prozedurnamen - nicht nur für eine Anweisungsfolge, sondern auch für einen
(Ergebnis-) Wert von einem vereinbarten (Ergebnis-) Typ. Funktionen können deshalb als
Teil von Ausdrücken verwendet werden. Das Funktionsergebnis wird explizit (mittels der
return Anweisung) zurückgegeben.
Rückgabetyp float
benutzerdefinierter Bezeichner
für die Funktion
public float gibSaldo( );
nach Außen
sichtbar
Prof. Dr. Nikolaus Wulff
diese Funktion hat
keine Parameter
26
Klassenimplementation
Die Implementation einer Java-Klasse wird mit der Definition zusammen in
derselben Datei .java durchgeführt. Beispiel: Sparbuch.java
public class Sparbuch {
private float saldo = 0;
• Für jedes Argument in der
Liste der Parameter wird
gesondert der Typ angegeben.
public void einzahlen(float wert){ • Eine Funktion gibt ihren
Rückgabewert mit return
this.saldo += wert;
zurück.
}
• Wo immer im Code der
public float getSaldo() {
Funktion die returnreturn this.saldo;
Anweisung steht, wird die
Funktion verlassen.
}
Prof. Dr. Nikolaus Wulff
27
Kommentare
• Einzeiliger Kommentar:
r = p % q;
// Rest berechnen
• Mehrzeiliger Kommentar:
/*
in den Zeilen nach diesem
Kommentar wird der Rest
einer Division berechnet
*/
r = p % q;
• Kommentare sind ein wichtiger
Bestandteil eines Programms.
• Mittels JavaDoc wird eine HTML
Dokumentation generiert.
• Dies erleichtert das Verständniss
und die Wartbarkeit.
• Durch entsprechende Tools, wie
z.B. Jalopy, lassen sich Regel zur
Dokumentation einhalten.
• Kommentare immer eine logische Abstraktionsebene höher als der Code.
• Nicht:
b = (a / 100) * 16; // 16% von a berechnen
• Sondern:
b = (a / 100) * 16; // MWSt. berechnen
Prof. Dr. Nikolaus Wulff
28
Ausnahmen
• Was passiert bei fehlerhaften Abläufen? Beispielsweise:
– Parameter haben falsche oder inkonsistente Werte.
– Bedingungen gelten nicht.
– Es fehlen Werte.
int teile(int a, int b) {
if (b == 0) { /* ??? */ }
else return a / b;
Was soll hier passieren?
}
• Rückgabe von „Fehlerwerten“ (0, -1, null, "", "ERROR") nicht
empfehlenswert, weil bei jedem Aufruf eine Prüfung erfolgen muss:
int ergebnis = teile(8, 0);
if (ergebnis == 0) { /* Fehler */ }
else ...
Prof. Dr. Nikolaus Wulff
29
Erzeugung von Ausnahmen
•
Ausnahme bedeutet: Die Bearbeitung kann nicht ordnungsgemäß
fortgesetzt werden.
• Eine Ausnahme ist ein Objekt.
• Auslösen einer Ausnahme:
Konstruktor
if (b == 0)
throw new ArithmeticException();
•
Ausnahmen können Parameter erhalten, wie bei jedem Konstruktor:
Parameter
if (t == null)
throw new NullPointerException("t==null");
•
Mit dem throw Konstrukt wird der aktuelle Programmfluß
unterbrochen und die Methode verlassen.
Prof. Dr. Nikolaus Wulff
30
Ausnahmebehandlung
try {
...
Block, der evtl. Ausnahmen auslöst
} catch(ExceptionTyp1 e1) {
...
Behandle die Ausnahmen des Typs ExceptionTyp1
} catch(ExceptionTyp2 e2) {
...
Behandle die Ausnahmen des Typs ExceptionTyp2
}
Beispiel
try {
throw new Exception("Here's my Exception");
} catch(Exception e) {
e.printStackTrace();
}
Prof. Dr. Nikolaus Wulff
31
Einfangen von Ausnahmen
• Alle eigenen Ausnahmen werden von der Klasse
Exception abgeleitet.
Exception
MyException1
MyException11
MyException2
try { ...
} catch(MyException1 e) {
...
Behandle die Ausnahmen des Typs
MyException1und der Subklassen
} catch(Exception e) {
...
Behandle
alle weiteren Ausnahmen
}
• Achtung: Beim Einfangen einer Ausnahme einer bestimmten
Klasse werden auch alle Ausnahmen von Subklassen
eingefangen.
Prof. Dr. Nikolaus Wulff
32
Ausnahme-Klassenhierarchie
•
Alle Ausnahmen müssen behandelt werden (in try-catch-Blöcken), bis
auf Ausnahmen der Klasse RuntimeException und deren
Subklassen.
•
Systemfehlermeldungen sind von der Klasse Error abgeleitet.
Throwable
Exception
MyException
Error
RuntimeException
NullPointerException
IlegalArgumentException
Prof. Dr. Nikolaus Wulff
33
Die if-else-Anweisung
• Beispiel 1:
if (expression)
statement-1;
else
statement-2;
if (x < 0)
y = -1;
else if (x > 0)
y = 1;
else
y = 0;
• Beispiel 2:
if (x > 0)
if (x == 42)
y = 4711;
else
y = 0;
Prof. Dr. Nikolaus Wulff
• Beispiel 3:
if (x > 0) {
if (x == 42) {
y = 4711;
} else {
y = 0;
}
}
• Vorsicht bei geschachtelten
if-Anweisungen: ein elseZweig bezieht sich immer auf
die letzte if-Anweisung ohne
else-Zweig.
• Explizite Klammerung hilft,
Fehler zu vermeiden !
34
Die for-Schleife
for (init-statement; expression-1; expression-2)
statement;
• Beispiel 1:
int fak;
for (fak=6; n > 1; n--)
{
fak = fak * (n - 1)
}
• Beispiel 2:
for (;;)
{
/* looping forever ... */
}
Vergleiche eine “saubere”
For-Schleife:
r := 0;
FOR i := 1 TO 99 BY 2
DO r := r + i
END;
Prof. Dr. Nikolaus Wulff
• Bei Eintritt in die for-Schleife kann keine
feste Anzahl von Durchläufen garantiert
werden, da der Wert der Laufvariablen
innerhalb des Rumpfes der for-Anweisung
verändert werden darf.
• Da expression-2 ein beliebiger Ausdruck
sein kann, ist nicht gewährleistet, daß die
Laufvariable bei jedem Durchlauf erhöht
bzw. erniedrigt wird.
• Da expression-1 ein beliebiger Ausdruck
sein kann, ist nicht einmal gewährleistet,
daß die Steuerung und der Abbruch der
Schleife überhaupt mit Hilfe einer
Laufvariablen erfolgt.
35
Übung
• Wir schreiben ein Programm zur Berechnung der Fakultät.
• Ziele:
– Anwenden der for-Schleife und des if-Konstrukts.
– Kennenlernen des rekursiven Methodenaufruf.
– Implementierung einer Fehlerbehandlung.
Def.: a) als Produkt
n
n! :=
Prof. Dr. Nikolaus Wulff
k
∏
k=1
b)
per Rekursion
1! := 1
n! := n*(n-1)!
36
Die switch-Anweisung
• Beispiel:
ch = ‘a’;
case label
switch ( ch )
{
case ‘A’:
case ‘a’: a_counter++;
break;
case ‘E’:
case ‘e’: e_counter++;
break;
case ‘I’:
case ‘i’: i_counter++;
break;
case ‘O’
case ‘o’: o_counter++;
break;
case ‘U’:
case ‘u’: i_counter++;
break;
default:
consonant_counter++;
break;
• Als case label verwenden wir
Konstanten vom Typ int,
long oder char.
Was passiert, wenn
• die break-Anweisung fehlt ?
• zwei case label denselben Wert
haben ?
• keiner der Fälle zutrifft und die
default-Anweisung fehlt ?
};
Prof. Dr. Nikolaus Wulff
37
Die while- und do-Schleife
• Beispiel einer while-Schleife:
r = p
while
{
p
r
}
% q;
(r != 0)
= q; q = r;
= p % q;
• Dasselbe Beispiel als do-Schleife:
r = p % q;
if (r != 0)
do
{
p = q; q = r;
r = p % q;
} while (r != 0);
while-Schleifen lassen sich immer
als do-Schleifen formulieren.
Prof. Dr. Nikolaus Wulff
while (expression)
statement;
do
statement;
while (expression)
• Vorsicht: die do-Schleife ist genau wie
die while-Schleife eine “SolangeNoch” Schleife. Der Schleifenkörper
wird ausgeführt, solange die Wiederholungsbedingung noch gültig ist.
• while-Schleifen testen die Wiederholungsbedingung vor dem ersten
Durchlauf. Ungeschützte do-Schleifen
laufen vor dem Test mindestens einmal
durch.
38
Konvertierungen
Automatisch
short nach int
int nach long
long nach float
float nach double
String
Automatische Konvertierung
mit + Operator.
Z.B. 15 + „ DM“
2 + 11 + „ DM“
„DM „ + 11 + 2
Manuelle Konvertierungen
Explizit casten
Z.B.:
double d = 1.23;
float f = (float) d;
Prof. Dr. Nikolaus Wulff
39
Werkzeuge im JDK
Falls keine IDE zur Verfügung steht...
• Java - Interpreter führt Java-Byte-Code aus.
• Javac - Compiler für Java-Programme. Übersetzt Java-Quellcode
in Java-Byte-Code.
• Jdb - Kommandozeilen-Debugger.
• Javap - Disassembler für Java-Byte-Code.
• Javadoc - Erzeugt Dokumentation zu Java-Klassen in HTML.
• Appletviewer - Führt Applets aus.
• Java-Quellen haben die Endung „.java“.
• Java-Byte-Code hat die Endung „.class“.
Prof. Dr. Nikolaus Wulff
40
JavaDoc
Die Dokumentation gehört - ebenso wie lauffähige Tests zur Qualitätssicherung eines jeden Projekts!
• Dokumentation kann durch Meta-Tags angereichert werden.
• Notwendige Kommentarform:
•
/**
* @author Dr. Nikolaus Wulff
*/
Weitere mögliche Meta-Tags, die von JavaDoc verwendet werden:
• @author
• @version
• @param
• @return
• @exception
• @since
• @see
Prof. Dr. Nikolaus Wulff
41
Die JDK API als JavaDoc
Packages
Klassenbeschreibung
Klassen
Prof. Dr. Nikolaus Wulff
42
Übung
• Entwickeln Sie einen Taschenrechner.
– Er bietet die vier grundlegenden Operationen +,-,*,/, die als
Zeichen oder Text (add, sub, mult, div) eingegeben werden
können.
– Die Ein- und Ausgabe erfolgt per Console.
Prof. Dr. Nikolaus Wulff
43
Übung
• Ziele:
–
–
–
–
Anwenden des switch-case Konstrukts.
Verwendung von Arrays.
Auswerten der Kommandozeile
Erweiterung der Fehlerbehandlung durch das Konzept
der Assertions.
– Erstellung einer Dokumentation mit Javadoc.
Prof. Dr. Nikolaus Wulff
44
Hinweis
•
•
Trennen Sie das Parsen der Kommandozeile von der Berechnung.
Verzweigen Sie in die eigentliche Berechnung mit einem switchcase Konstrukt.
•
Zur Typumwandlung von String nach double die Klasse
java.lang.Double verwenden. In JavaDoc nachschauen...
•
Geben Sie eine Fehlermeldung bei falschen Argumenten aus.
Prof. Dr. Nikolaus Wulff
45