Folien zur Vorlesung

ALP II: Objektorientierte
Programmierung
Sommersemester 2006
Elfriede Fehr, Mohammad Al Saad
Teil I: Grundlagen der Berechenbarkeit
Die Programmiersprache WHILE und
die universelle Registermaschine
WHILE-Anweisungen:
x := 0;
x := x + 1;
x := x – 1;
while x  y do
<Anweisungen>
end
Befehlssatz der Registermaschine:
zero i
succ i
pred i
je i, j, m
goto m
Übersetzung von WHILE-Programmen in
Registermaschinenprogramme:
Erster Schritt: Erzeugen der Symboltabelle st
Beispiel für eine Symboltabelle
Variablen im WHILEProgramm
Korrespondierende
Adressen im Datenspeicher
a
0
x
1
y
2
h
3
Zweiter Schritt: Anwendung des
Übersetzungsschemas (Ü)
x := 0;
zero st(x)
x := x + 1;
succ st(x)
x := x – 1;
while x  y do
pred st(x)
m : je st(x), st(y), k
<Anweisungen>
end
Ü <Anweisungen>
goto m
k:…
Achtung:
m ist die Adresse des ersten Befehls, der zur While-Schleife gehört und
k ist die Adresse des ersten Befehls, der nicht mehr zur While-Schleife gehört.
Beispiel: Fakultätsfunktion
Funktionales Programm (Haskell):
f 0=1
f x = x * f (x - 1)
Imperatives Programm (in der Sprache WHILE):
y := 1; h:= 0;
while x ≠ h do
y := x * y;
x := x - 1;
end
Übersetzung des WHILE-Programms in ein
Registermaschinenprogramm
WHILEAnweisung
Nr. im
Befehlsregister
Maschinenbefehl
y := 1;
0
one 0
h := 0;
1
zero 2
while x ≠ h do
2
je 1, 2, 6
y := h * y;
3
mult 0 1
h := h - 1;
4
5
pred 1
goto 2
6
stop
end
Übersetzung von WHILE nach Java
y := 1;
y = 1;
while x ≠ 0 do
while (x != 0) {
y := x * y;
y = x * y;
x := x - 1;
x = x - 1;
end
}
Übersetzung von Java in Bytecode analog zur Übersetzung von WHLIE
in Registermaschinenprogramme. Illustration unter
http://www.artima.com/insidejvm/applets/EternalMath.html
Ein vollständiges Java-Programm
public class Fak {
//Aufruf: Fak x , Ausgabe: Fakultät von x = Ergebnis
//Hauptprogramm
public static void main (String[] args) {
// Deklaration aller benötigter Variablen
int x, y, h;
// Eingabe von x
x = Integer.parseInt (args[0]);
// Berechne y := Fakultät von x
y = 1;
h = x;
while (h != 0) {
y = h * y;
h = h - 1;
}
// Ausgabe des kommentierten Ergebnisses
System.out.println("Fakultät von " + x + " = " + y);
}
}
Teil II: Datentypen in Java
Syntax
Type:
Datentyp:
PrimitiveType
ReferenceType
PrimitiverTyp
VerweisTyp
PrimitiveType:
NumericType
boolean
PrimitiverTyp:
NumerischerTyp
boolean
NumericType:
IntegralType
FloatingPointType
NumerischerTyp:
GanzzahligerTyp
GleitkommaTyp
IntegralType: one of
byte short int long char
GanzzahligerTyp: einer von
byte short int long char
FloatingPointType: one of
float double
GleitkommaTyp: einer von
float double
James Gosling et al.:
The Java Language Specification,
sun microsystems 2005
Primitive Datentypen
Type
Wertebereich
byte
-128 … 127
1 Byte (8 Bits)
-78
short
-215 … 215-1
2 Bytes
32767
int
-231 … 231-1
4 Bytes
-2147483648
long
-263 … 263-1
8 Bytes
s.o.
4 Bytes
3.14159F
8 Bytes
1.32E-20
float
double
6 signifikante Ziffern (1046 1038)
15 signifikante Ziffern
(10-324 10308)
Speicherung Bsp.Konstante
char
Unicode-Zeichen
2 Bytes
‘A‘
boolean
false, true
1 Byte
true
Arithmetische Operationen
erklärt auf allen numerischen Typen
Operator
einstelliges +
einstelliges -
Bedeutung
Identität
Negation
Beispiel
+4
- (4 + 5)
Ergebnis
4
-9
*
/
%
Multiplikation
Division
Rest
8*3
8/3
8%5
24
2
3
+
-
Addition
Subtraktion
5+6
- (4 + 5)
11
-9
Vergleichsoperationen
erklärt auf allen numerischen Typen, die beiden letzten
auch auf boolean
Operator
Bedeutung
Beispiel
Ergebnis
<
<=
kleiner
kleiner gleich
25 < 59
45 <= 44
true
false
>
>=
größer
größer gleich
3>3
3 >= 3
false
true
==
!=
gleich
ungleich
3 == 5
3 != 5
false
true
Typanpassung
– Implizit von engeren zu weiteren Typen
– Explizit in beide Richtungen
Definition der Relation „enger“ (  ):
byte  short  int  long  float  double
char  int
Bemerkung: Die Relation  ist transitiv.
Explizite Typanpassung des Wertes eines Ausdrucks A an einen Typ t durch
Anwendung des einstelligen Operators (t) auf den Ausdruck A.
Beispiele:
byte b = 9; b = b + 1;
ist illegal!
byte b = 9; b = (byte) (b+1); ist legal.
int x = 6, y = 10;
double q = x / y; der Wert von q ist 0.0
double q = (double)x / y; der Wert von q ist 0.6
Syntaxregeln für Bedingte
Anweisungen und Schleifen
CondStmt:
if (Exp) Stmt [ else Stmt ]
WhileStmt:
while (Exp) Stmt
ForStmt: for ( [Init]; [Exp]; [Update]) Stmt