Post on 01-May-2022
Vorlesung3. Sitzung
GrundlegendeProgrammiertechniken
Dozent
Nino Simunic M.A. Computerlinguistik, Campus DU
Wintersemester 2007/2008
�Grundlegende Programmiertechniken, WS 2007/2008
� Ausdrücke, Operatoren
� Kontrollfluss steuern via Verzweigung
----3333----
Ausdrücke: Einleitung
� Allgemein: Elementarsten (ausführbaren) Programmeinheiten, welche einen Wert haben/zurückgeben:� Literale, Numerale, Variablen
� Komplexe/Zusammengesetzte Ausdrücke� bestehen aus Klammern, Operanden und Operatoren
� beschreiben bspw. eine Berechnungsvorschrift
Einschub: Literale/Numerale in Java ����
----4444----
Einschub: Literale/Numerale in Java
� Explizite Repräsentation von Werten primitiven Typs und Zeichenketten (Strings) im Quelltext:
� Boolesche Literale� true oder false
� Zeichen Literale� '€', '\u20ac', …
� Fließkomma Literale (Numerale)� 1.5, 124.1255
� Integer/Ganzzahl Literale (Numerale)� 12, 45, 823462346
� Null Literal� null
� Zeichenketten (String-)Literale� "Hello, Dave"
Ausdrücke: Zusammengesetzte, Anweisung ����
----5555----
Ausdrücke: Zusammengesetzte, Anweisung
� Zusammengesetzer Ausdruck: Kombination aus Operator(-en) und Operand(-en)� Dienen bspw. dazu,
� Variablen einen Wert zuzuweisen (a = 12)
� numerische Berechnungen durchzuführen (12 + 4)
� logische Bedingungen zu formulieren ( x>2 || y<4 )
� Ein auf ein Semikolon endender Ausdruck isteine Anweisung. � double spdProzent
= prozentWert * grundWert / 100;
Ausdrücke: Operanden ����
----6666----
Ausdrücke: Operanden
� Operanden in Ausdrücken � Sind die bereits vorgestellten Literale oder Variablen.
� Zum Beispiel:� double d = 5 * 10 / y ;
� String date = "18.11." + yearVar;
� Methoden- bzw. Konstruktorenaufrufe� Integer.parseInt(args[0])*Math.random()*3.5
� Hinweis: In Java existieren keine Funktionen, sondern Methoden. In beiden Fällen: Sie können Werte zurückgeben! Mehr zum Konzept »Methoden« später.
Ausdrücke: Typ, Rückgabewert ����
----7777----
Ausdrücke: Typ, Rückgabewert
� Jeder Ausdruck hat einen Rückgabewertbestimmten Typs.
� Der Typ des Rückgabewerts bestimmt sich aus den Typen der Operanden und der Art des verwendeten Operators. Zum Beispiel:� a > b ( Relationaler Operator, Typ: boolean )
� 2 + 5 ( Arithmetisch. Op.,Typ: int, short, long, …)
Operatoren: Allgemeine Unterscheidungsebenen ����
----8888----
Operatoren: Allgemeine Unterscheidungsebenen
� Operator(-typ)� Arithmetischer Operatoren, Logische O., …
� Stelligkeit
� Stellung
� Präzedenz
� Assoziativität
Stelligkeit ����
----9999----
Operatoren: Stelligkeit
� Die Stelligkeit des Operators
bestimmt die Anzahl obligatorischer Operanden � unär: ein Operand (bspw. bei der Negation (-a);
� binär : zwei Operanden (bspw. Addition: a + b)
� ternär : drei Operanden (bspw. a ? b : c)
Stellung ����
----10101010----
Operatoren: Stellung
� Allgemeine Unterscheidung nach Stellungskriterien: Infix, Präfix, Postfix
� Infix� Zwischen den Operanden. Bspw. Addition:a + b
� Präfix � Vor dem Operanden. ++a
� Postfix � Nach dem Operanden. a++
Präzedenz (a) ����
----11111111----
Operatoren (a): Präzedenz
� Präzedenz ((Vor-)Rang, Priorität) eines Operators bestimmt die Reihenfolge der Ausführung der Operationen, wenn ein Ausdruck mehrere Operatoren enthält. � Operationen mit höherer Priorität werden vor
Operationen mit niedriger Priorität ausgeführt.
� Durch Klammerung kann diese Ausführungsreihenfolge modifiziert werden.
� Bei Operanden gleicher Priorität muss die Assoziativität der Operatoren beachtet werden.
Präzedenz (Beispiele) ����
----12121212----
Operatoren (b): Präzedenz
� Multiplikation vor Addition (Punkt vor Strich) � a - b * c / d
� Enstprechung: ( a - ( ( b *c ) / d ))
� (a –b ) * c / d
� Enstprechung: ( ( (a - b) * c ) / d )
� Änderung der Priorität via Klammerung
� Präzedenz bei Zuweisung und Berechnung: Zuweisungsoperatoren haben eine niedrigere Präzedenz als arithmetische Operatoren:� a = a + 1
� Zuerst wird rechts a + 1 ausgewertet, dann der Ergebniswert zugewiesen.
Assoziativität ����
----13131313----
Ausdrücke: Assoziativität
� Assoziativität beschreibt die Auswertungsreihenfolge von Operatorenderselben Bindungskraft. Zwei Ausprägungen:
� Links-Assoziativität � Z.B. sind Summationsoperatoren sind linksassoziativ:
� Auswertung von a-b+c als (a-b)+c und nicht als a-(b+c)
� Rechts-Assoziativität� Bspw. Zuweisungsoperatoren sind rechtsassoziativ:
� Auswertung von b = a = 1 wie b = ( a = 1 )
Operationstypen ����
----14141414----
Operatoren: Typen
� Arithmetische Operatoren� Bspw. + oder -
� Bit-Operatoren� Bspw. >> oder &
� Vergleichsoperatoren� Bspw. '>' oder '<'
� Logische Operatoren� Bspw. '&&' oder '||'
� Zuweisungsoperatoren� Bspw. '=' oder '+='
� Sonstige� Bspw. Konkatenations-Plus, (ZIELTYP) oder ? :
Arithmetische, Vorzeichen Op. ����
----15151515----
Operatoren: Arithmetische O., Vorzeichen O. (1)
� Allgemein: Arithmetische Operatoren verrechnen ein oder zwei Werte zu einem neuen Wert
� Insgesamt fünf arithmetische Operatoren und zwei Vorzeichen-Operatoren:� Binäre additive Operatoren:
� + Addition (Priorität 5/15, linksassoziativ)� - Subtraktion (Priorität 5/15, linksassoziativ)
� Binäre multiplikative Operatoren: � * Multiplikation (Priorität 4/15, linksassoziativ)� / Division (Priorität 4/15, linksassoziativ)� % Modulus (Rest-Operator) (Priorität 4/15, linksassoziativ)
� Vorzeichen � + Identität (unäres Plus) (Priorität 2/15, linksassoziativ)� - Negation (unäres Minus) (Priorität 2/15, linksassoziativ)
ArithmeticOps.java ����
----16161616----
ArithmeticOps.java
class ArithmeticOps {
public static void main(String[] args) {
int a = 4;
int b = 2;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
System.out.println(a % b);
System.out.println(a * -b);
System.out.println(-a * -b);
}
}
Operatoren: Typ eines Ausdrucks (1) ����
----17171717----
Operatoren: Typ eines Ausdrucks (1)
� Jeder Ausdruck hat einen Typ
� Zwei Möglichkeiten:� Ausdruck-Elemente sind gleichen Typs
� Dann ist der Typ des Ausdrucks identisch mit dem Typen seiner Elemente.
� Ausdruck-Elemente sind unterschiedlichen Typs� Dann hat der Ausdruck den Typ des
genaueren/umfassendsten Typs im Ausdruck� double (1.2) ist umfassender/genauer als int (1)
Operatoren: Typ eines Ausdrucks (2) ����
----18181818----
Operatoren: Typ eines Ausdrucks (2)
� Operanden eines Ausdrucks müssen kompatibel sein� int x; x = 2.5;
� Kompilierungsfehler: Datentypen sind nicht kompatibel
� Zwei Typen sind kompatibel, wenn� sie identisch sind, oder
� wenn sie durch implizite Typanpassung/-konvertierung zum gleichen Typ führen
Typkompatibilität ����
----19191919----
Typkompatibilität, Cast-Operator
� Implizite (automatische) Typkonvertierung� byte→short→int→long→float→double(→ String)
� Z.B. von short nach long ok, von long nach short ungültig.
� Explizite Typanpassung via Cast-Operator� Syntax:(TYPE) expression
� Beispiel:int x;
x = (int) 2.5;
� Kann zu Datenverlust und Ungenauigkeit führen! � x ist jetzt 2
Beispiele, Typkompatibilität ����
----20202020----
»Arithmetische« Ausdruckstypen, Typkompatibilität (1)
int i1=4, i2=2, i3=5;
double d1 = 3, d2 = 2;
System.out.println(i1 = i1 + i2 ); // i1=?
// 6
/* i1 hat Typ int, i2 hat Typ int, also hat der Ausdruck den Typ int */
System.out.println(d1 = d2 + i2 ); // d1=?
// 4.0
/*d2 hat Typ double,i2 hat Typ int -> Ausdruck hat den genaueren Typ
* double */
Bsp.: (Un-)Genauigkeiten ����
----21212121----
»Arithmetische« Ausdruckstypen, Typkompatibilität (2)
System.out.println( i1 = i3 / i2 );
// i1 jetzt 2
/* i1 hat Typ int, i2 hat Typ int, also hat auch der Ausdruck den Typ
int. In solchen Fällen wird immer gen .0 gerundet */
System.out.println( d1 = i3 / i2 );
//2.0
/* a) Beide Op. Typ int, Ausdruck Typ int -> Wert ist 2 (Rundung zu .0)
* b) Zuweisung von int zu double, implizit: d1 daher 2.0
*/
System.out.println( d1 = i3 / d2 );
// 2.5
/* Rechter Ausdruck vom genaueren Typ double.
* Berechnung genauso genau: 2.5 (keine Rundung!)*/
Bsp.: cast ����
----22222222----
»Arithmetische« Ausdruckstypen, Typkompatibilität (3)
System.out.println( d1 = (double) (i3 / i2) ); //d1=?
//2.0
/* a) Typecast zwecklos, da rechter Ausdruck wg. Klammerung höchste
Priorität hat.
* Wird erst zu 2.0 ausgewertet, dann zu double gecastet (noch immer
2.0), dann 2.0
* der double-Var. zugewiesen. */
System.out.println( d1 = (double) i3 / i2 ); //d1=?
//2.5
// a) Cast (Op.) jetzt höchste Prioriät im Ausdruck. i3 wird zu
kompatiblem double.
// b) Ganzer Ausdruck wird wg. i3 zu double.
// c) Berechnung auf double-Ebene (ohne Rundung!): 2.5
System.out.println( d1 = i3 / (double) i2 ); //d1=?
//2.5
// Analog zu Bsp. oberhalb: Diesmal i2 statt i1
Operatoren: Logische Operatoren (1) ����
----23232323----
Operatoren: Logische Operatoren (1)
� Verrechnung von ein oder zwei Wahrheitswerten zu einem neuen Wahrheitswert
� 6 logische Operatoren (a,b: Typ boolean)� Logisches/Bitwise Und: a & b (Priorität 9/15, linksa.)
� Logisches/Bitwise Oder: a | b (Priorität 11, linksa.)
� Logisches Nicht: ! b (Priorität 2, linksa.)
� Logisches/Bitwise XOR: a ^ b (Priorität 10, linksa.)
� …
wfwahr
fffalsch
wahrfalsch&
wwwahr
wffalsch
wahrfalsch|
fwwahr
wffalsch
wahrfalsch^
Operatoren: Logische Operatoren (2) ����
----24242424----
Operatoren: Logische Operatoren (2)
…� Logisches UND mit Short-Circuit-Evaluation (Prio. 12, la.):
� a && b
� Ist a bereits falsch, so wird false zurückgegeben und b nicht mehr ausgewertet.
� Anders bei & (Auswertung stets beider Teile)
� Logisches ODER mit Short-Circuit-Evaluation (Prio. 13, la.):� a || b
� Ist bereits a wahr, so wird true zurückgegeben und b nicht mehr ausgewertet.
� Anders bei | (Auswertung beider Teile, egal ob a bereits wahr ist)
� Unvollständige Auswertung, analog zu: � if (a) {
if (b) { …
Logik/Bool'-Operatoren: BoolOps.java ����
----25252525----
Logik/Bool'-Operatoren: BoolOps.java
public class BoolOps {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println( a & b );
// false
System.out.println( a | b );
// true
System.out.println( a ^ b );
// true
System.out.println( ! b );
// true
// wenn a false ist, Auswertung beendet (ignoriere b):System.out.println( a && b ); // false
// wenn a true ist, ignoriere den zweiten Operanden b:System.out.println( a || b ); // true
}
}
Operatoren: Zuweisungsoperatoren ����
----26262626----
Operatoren: Zuweisungsoperatoren
� Zuweisungsoperatoren weisen einen Wert zu und liefern den Wert dann als Ergebnis an aufrufender Stelle� Sie sind die einzigen Operatoren »Seiteneffekt«
� Insgesamt 12 Operatoren, Priorität 15 (/15, also schwächste)� =, +=,-=,*=,/=,%=,&=,^=,|=,, <<=, >>=, >>>=
� Bei den Operatoren +=, %=, … handelt es sich um Kurzformen für eine Berechnung mit folgender Zuweisung.
Operatoren: Zuweisungsoperatoren ����
----27272727----
Beispiele: Zuweisungsoperatoren
int a = 4;
int b = 2;
System.out.println(a = b);
// 2
System.out.println(b = 5);
// 5
System.out.println(a += b);
// 7 (analog zu a = a + b)
System.out.println(a += a = b);}
// Erst a = b (a=5), dann a + b, dann das »alte« a (7) + »neues« a (5),
// ergibt 12, dann letzte Zuweisung (a = 12)
Operatoren: Pre-Inkrement/Dekrement ����
----28282828----
Operatoren: Pre-Inkrement/Dekrement
� Pre-Inkrement/Dekrement (++x, ++y)� Verändert den Wert der Variablen und liefert diesen (neuen Wert) an aufrufender
Stelle als Ergebnis zurück!� Priorität 1/15(höchste), linksassoziativ
� Post-Inkrement/Dekrement (x++, y++)� Verändert den Wert der Variablen, liefert aber an ausführender Stelle den alten
Wert als Ergebnis zurück!� Priorität 2/15(zweithöchste), rechtsassoziativ
int a=5;
//Seiteneffekt: a)Zuweisung per se (b jetzt 5),
// b)gesamter Ausdruck gibt den Wert 5 zurück:
int b=a;
System.out.println( "(Post-inkr.) a an ausführender Stelle: " + a++);
System.out.println( "a danach: " + a);
System.out.println( "(Pre-inkr.) b an ausführender Stelle: " + ++b);
System.out.println( "b danach: " + b);
5
6
6
6
Inkrement hat höhere Präzedenz (Prio. 1) als Konkatenationsoperator ( Prio. 5)
Operatoren: Vergleichsoperatoren ����
----29292929----
Vergleichsoperatoren
� Vergleichsoperatoren liefern immer einen Wahrheitswert (boolean) zurück. � Beide Operanden müssen einen kompatiblen Typ haben
� Vergleich (Priorität 7/15, linksassoziativ): � < kleiner als
� <= kleiner gleich
� > größer als
� >= größer gleich
� Äquivalenz (Priorität 8/15, linksassoziativ): � == gleich
� != ungleich
Vergleichsoperatoren, Quelltext : CompOps.java ����
----30303030----
Vergleichsoperatoren, Quelltext : CompOps.java
class CompOps {
public static void main(String[] args) {
int a = 5;
int b = 3;
System.out.println( a == b ); // false
System.out.println( a != b ); // true
System.out.println( a > b ); // true
System.out.println( a < b ); // false
System.out.println( a >= b ); // true
System.out.println( a <= b ); // false
}
}
Vorsicht Falle! = ist Zuweisung, == ist Vergleich. Immer. Überall.
Operatoren: Bitwise ����
----31313131----
Operatoren: Bitwise
Shift des Bits von n rechts um pPositionen. Nullen werden zu high-order Positionen geshiftet.
15-4 >>> 28 right shift
n >>> p
Shift des Bits von n rechts um pPositionen.
15 >> 2right shift
n >> p
Shift des Bits von n links um pPositionen. 0-Bits werden in low-order Positionen geshiftet.
123 <<< 2left shift
n << p
Invertiert die Bits.-4~3 not~a
1, wenn beide Bits unterschiedlich sind.
63 ^ 5 xora ^ b
1, wenn eines der Bits 1 ist.73 | 5 ora | b
1, wenn beide Bits 1 sind.13 & 5anda & b
DescriptionErgebnisBeispielNameOperator
Illustration (1): Präzedenz und Assoziativität ����
----32323232----
Illustration (1): Präzedenz und Assoziativität
double z,p,r,q,w,y,x;
z = p = r = q = w = y = x = 0.0; //...
Illustration (2): Präzedenz und Assoziativität ����
----33333333----
Illustration (2): Präzedenz und Assozation
If-else ����
�Grundlegende Programmiertechniken, WS 2007/2008
Kontrollfluss steuern (Verzweigung)
----35353535----
� Bisher:� Anweisungsabfolge linear
� Nur ein Pfad durch die Anweisungen
� Jede Anweisung wird genau einmal ausgeführt
� Was ist, wenn� Entscheidungen getroffen werden sollen?
� Anweisungen wiederholt werden sollen?
� Notwendigkeit: Kontrollfluss steuern� Umsetzung: Verzweigende Anweisung (via if-else)
If-else: Allgemeine Form ����
Entscheidungen fällen
----36363636----
If-else: Allgemeine Form
Bedingungen ����
----37373737----
Bedingungen
IfElseTest.java ����
----38383838----
If-Else im Quelltext: IfElseTest.java
class IfElseTest {
public static void main(String[] args) {
int eingabe = -14;
if (eingabe<0) {//fuehre erste Anweisung aus, falls Bedingung true
System.out.println(-eingabe);
}
else { // fuehre zweite Anweisung aus, falls Bedingung false
System.out.println(eingabe);
}
// Bei einfachen Konstrukten auch Formatierung anstatt Klammerung:
if (eingabe<0)
System.out.println(-eingabe);
else // fuehre zweite Anweisung aus, falls Bedingung false
System.out.println(eingabe);
}
}
(Einschub) Sonstige Operatoren: Tern-Operator ����
----39393939----
(Einschub) Sonstige Operatoren: Tern-Operator (TernOp.java)
class TernOp {
public static void main(String[] args) {
int eingabe = -5;
int zahl = (eingabe < 0) ? -eingabe : eingabe ;
System.out.println(zahl);// 5
eingabe = 7;
System.out.println((eingabe < 0) ? -eingabe : eingabe);
}
}
Ende ����
----40404040----
Nächste Woche
� Objektorientierte Programmierung, Teil 1� Klassen, Objekte, Konstruktoren, Methoden
-----------------
Tutorien:
Personen, die sich fürs Tutorium interessieren, schicken mir bitte bis kommenden Montag eine Mail mit Wunschzeiten (zwei sollten es schon sein).