Bearbeiten von „Ausdrücke:Javakurs“

[[Category:Tutorial]]
[[Category:Java]]

[[JavaTutorial|Übersicht]]

== Theorie ==
Ein Ausdruck ist eine Verknüpfung von Operanden mittels Operatoren.

Es gibt 1-, 2- und 3-stellige Operatoren.

=== 1-stellige Operatoren ===
{|
| Operator
| Bemerkung
| Beispiele
|-
| '-'
| negiert einen artithmetischen Ausdruck
| - (a + b)
|-
| '!'
| negiert einen boolschen Ausdruck
| ! again
|}

==== Inkrement, Decrement ====
Einen Sonderfall bilden die 4 Operatoren Post-Increment, Pre-Increment, Post-Decrement und Pre-Decrement.
Sie können nur auf Variablen angewendet werden, nicht auf Konstanten oder andere Ausdrücke.

Die 2 Post-Operatoren verändern den Wert der Variablen nach der Auswertung, die Pre-Operatoren vorher.

Beispiel:
<pre>int a = 5;
System.println(String.format("a = 5; 2 * a++ = %d", 2 * a++));
System.println(String.format("a: %d", a));

a = 5;
System.println(String.format("a = 5; 2 * --a = %d", 2 * --a));
System.println(String.format("a: %d", a));
</pre>
Ausgabe:
<pre>a = 5; 2 * a++ = 10
a: 6
a = 5; 2 * --a = 8
a: 4
</pre>

=== 2-stellige Operatoren ===
{|
| Operatoren
| Bemerkung
| Beispiele
|-
| '+' '-' '*' '/' '%'
| Arithmetik: addieren, subtrahieren, multiplizieren, dividieren, modulo
| a + b*c - (d % 2)
|-
| '==' '!='
| Vergleich: gleich, ungleich
| n == 0 && m != 3
|-
| <nowiki>'<' '>' '<=' '>='</nowiki>
| Vergleich mit Sortierung: kleiner, größer, kleiner gleich, größer gleich
| n >= 0 && n < max
|-
| <nowiki>'||'</nowiki> '&&'
| boolsche Arithmetik
| <nowiki>a || b && c</nowiki>
|-
| <nowiki>'|'</nowiki> '&' '^'
| Bit-Manipulation
| a | (b & (c ^ 0xff))
|-
| '=' '+=' '-=' '/=' '*=' '%='
| Zuweisung
| a = (b = 5) + 1; a += 5;
|}
<b>Beachte</b>:
Der Operator "gleich" ist '==' (2 mal '='), nicht mit der Zuweisung '=' verwechseln!

=== 3-stelliger Operator ===
Es gibt genau einen 3-stelligen Operator, den bedingten Ausdruck:
<pre><nowiki><condition> '?' <true-expression> ':' <false-expression></nowiki>
</pre>
Es wird die Bedingung ausgewertet. Liefert diese den Wert true, ist das Ergebnis der erste Ausdruck,
sonst der zweite.

<b>Beispiel:</b>
<pre>
column % 2 == 0 ? "blue" : "red";
</pre>

== Der '+'-Operator für Strings ==
Der Datentyp String kennt genau einen Operator, das '+'.
Damit können Strings oder auch char-Ausdrücke zusammengesetzt werden.

=== Beispiel ===
<pre>
String s = "Hello";
char separator = ' ';
s = s + separator + "world";
</pre>

== Automatische Typanpassung in Ausdrücken ==
Werden verschieden Datentypen mit einem Operator verknüft, passieren automatische Anpassungen.
* Der "eingeschränktere" Operand wird in den umfassenderen Typ gewandelt.
* Reihenfolge der Typen: int long float double
* Da die Zuweisung auch ein Operator ist, gilt das auch für Zuweisungen: Wird an eine double-Variable ein int-Wert zugewiesen, wird automatisch konvertiert.
Beispiele: 
* Ist ein Operand ein int, der andere ein float, wird der int-Operand automatisch in float gewandelt und die Operation findet mit 2 float statt.
<pre>int a = 1;
float f = a / 2;
System.out.println(String.format("1/2 = %.3f", f);
System.out.println(String.format("1/2.0 = %.3f", a / 2.0));
</pre>
Ausgabe:
<pre>1/2 = 0.000
1/2.0 = 0.500
</pre>

== Explizite Typwandlung (Cast) ==
Soll ein Datentyp in einen anderen konvertiert werden, geschiet dies mit dem Cast-Operator: 

=== Syntax ===
<pre><nowiki>
'(' <data-type>')' <expr>
</nowiki></pre>

=== Beispiel ===
<pre>
double x = (double) 25;
x = (double) 5 / 3;
</pre>
Hinweis: Der Cast-Operator bindet stärker als das '/', dies entspricht also dem Ausdruck
<pre>x = ((double) 5) / 3;
</pre>

== Vorrangregeln (Prefärenzen) ==
Für jeden Operator gibt es einen Vorrang-Grad. 
Haben 2 Operatoren verschiedene Vorrang-Grade, wird zuerst die Operation mit dem höheren Grad ausgeführt.
Mit Klammern kann man die Vorrangregeln umgehen.

Die Kurzfassung:
* Für die arithmethischen Operatoren gilt die Rangfolge wie in der Mathematik: Punkt vor Strich.
* Arithmethik bindet stärker als Vergleiche
* Boolsche Operatoren binden schwächer als Vergleiche. '&&' bindet stärker als '||'.
* Die Zuweisung bindet schwächer als alle anderen Operatoren.
Ausführlich: [http://introcs.cs.princeton.edu/java/11precedence/ Operator-Präferenzen]

=== Beispiel ===
<pre>int x = ...;
boolean a = 0 >= x && x < 10 || x >= 20 && x < 30;
</pre>
ist äquivalent zu:
<pre>int a = ( ( (0 >= x) && (x < 10) ) || ( (x >= 20) && (x < 30) ) );
</pre>

== Aufgaben ==
* Gegeben: Dauer in Sekunden: duration gesucht: Stunden hour, Minuten min, Sekunden sec
<pre>int duration = 123483;
int hour = ...;
int min = ....;
int sec = ....;
</pre>
* Gegeben: x Gesucht: liegt x im Intervall [1991, 2009]
<pre>int x = ...;
bool inMarcsYouth = ...;
</pre>
* Gegeben: eine Zahl x. Gesucht: 0 wenn x gleich 0, -1 wenn x negativ, +1 wenn x positiv
<pre>int x = ...;
int sign = ...;
</pre>