Version vom 18. April 2016, 15:48 Uhr

Ein Term ist ein Ausdruck im Quellcode, der einen Wert berechnet oder repräsentiert.

Einen Term ohne weiteren Zusammenhang im Quelltext zu notieren ist ein Syntaxfehler, da der Wert eines Terms ohne Zuweisung oder Übergabe als Parameter einer Methode keinen Grund hat, berechnet zu werden.

Position im Quellcode

Ein Term kann im Quellcode an folgenden Stellen notiert werden:

1. Als rechte Seite einer Zuweisung
2. Als Argument einer bedingten Anweisung (nur Terme mit booleschem Ergebnis)
3. Als Argument einer Schleife (nur Terme mit booleschem Ergebnis)
4. Als Parameter eines Methodenaufrufs

Werte und Typen

Ein Term besitzt zwei Eigenschaften: Einen Wert und einen Datentyp. Der Term 8 und der Term8.0 besitzen zwar den gleichen Wert, aber die unterschiedlichen Typen int und double. Entsprechend werden die Werte der Terme binär unterschiedlich repräsentiert. Sie sind jedoch für arithmetische Operationen kompatibel und können aufeinander angewendet werden.

Die unterschiedlichen Typen, die ein Term haben kann, sind dieselben Typen, die eine Variable haben kann, um den entsprechenden Wert zu speichern. Näheres dazu siehe: Datentypen.

Termaufbau

Ein Term besteht entweder aus einem einzelnen Ausdruck oder aus einer Kombination von Termen mittels Operatoren. Ein einzelner Ausdruck ist entweder eine Konstante (z.B. 5), die ihren Wert direkt repräsentiert, oder eine Variable (z.B. x), die im Term ein Repräsentant für den in ihr gespeicherten Wert ist.

Konstante

Die grundlegende Form eines Terms ist eine Konstante.

int x = 5;

Variable

Eine Variable kann als einzelner Term verwendet werden, um den Wert der Variablen zu verwenden. Wichtig: Jede Variable wird in jedem Term immer zuerst zu ihrem Wert aufgelöst, bevor mit ihr gerechnet wird!

int x = 5;
int y = x; //y wird der Wert '5' zugewiesen

Arithmetischer Term

Terme, die numerische Werte repräsentieren, können mit arithmetischen Operatoren verknüpft werden um die entsprechende Berechnung zu repräsentieren. Der daraus entstehende Term repräsentiert das Ergebnis dieser Berechnung.

int x = 5;
int y = x;     //y wird der Wert '5' zugewiesen
x = 1;         //x wird der Wert '1' zugewiesen
int z = y + 8; //z wird der Wert '13' zugewiesen

Boolescher Term

Terme können mit Vergleichsoperatoren verglichen werden. Das Ergebnis eines solchen Vergleichs ist ein boolescher Wert: Wahr oder Falsch bzw. true oder false. Der Typ eines solchen Terms ist immer der eines boolean. Entsprechend können auf Termen, die einen Vergleich durchführen, nur boolesche Operationen ausgeführt werden. Ebenso können solche Terme überall da, wo ein boolescher Wert gefragt ist, nämlich in bedingten Anweisungen und Schleifen, verwendet werden.

int x = 5;
int y = x;         //y wird der Wert '5' zugewiesen
x = 1;             //x wird der Wert '1' zugewiesen
int z = y + 8;     //z wird der Wert '13' zugewiesen
boolean b = z > x; //b wird der Wert 'true' zugewiesen
if(y == x && b){   //Diese Schleife wird nicht ausgeführt, da 'y == x' 'false' ergibt und 'false && true' zu 'false' ausgewertet wird
    //...
} 

Referenzen

Terme, die eine Objektreferenz als Wert liefern, sind nur Instanziierungen, Methodenaufrufe oder Variablen selbst. Mit Referenzen kann in Java nicht gerechnet werden, anders als z.B. in C. Instanziierungen haben noch die besondere Eigenschaft, dass sie alleinstehend aufgerufen werden können, da sie mit einem Methodenaufruf gleichgesetzt werden können (s.u.).

Object object = new Object(); //object erhält die Referenz auf ein neues Objekt
Object same = object; //same übernimmt die Referenz auf das soeben erstellte Objekt

Methodenaufrufe

Ein 'Methodenaufruf kann auch alleinstehend verwendet werden, also nicht als rechte Seite einer Variablen usw. Der durch einen Methodenaufruf repräsentierte Term hat den Typ des Rückgabetyps der Methode und den Wert, den der Aufruf der Methode zurück gibt.

Sollte eine Methode void als Rückgabetyp angeben, ist ein alleinstehender Aufruf unproblematisch. Sollte eine Methode einen Wert zurückliefern, so gibt der Compiler eine Warnung aus, dass das Ergebnis des Aufrufs verloren geht und vermutlich ein semantischer Fehler vorliegt.