Dozent Nino Simunic M.A. - uni-due.de

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


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


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 {


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 {


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 {


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 {


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).

Dozent Nino Simunic M.A. - uni-due.de

Documents

Transcript of Dozent Nino Simunic M.A. - uni-due.de