Term

Ein Term ist ein Stück 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: Als...

1. ... rechte Seite einer Zuweisung
2. ... Argument einer bedingten Anweisung (nur Terme mit booleschem Ergebnis)
3. ... Argument einer Schleife (nur Terme mit booleschem Ergebnis)
4. ... 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) oder eine Variable (z.B. x), die im Term ihren Wert repräsentiert.

Konstante

Die grundlegende Form eines Terms ist eine Konstante.

int x = 5;

Variable

Eine Variable kann als einzelner Term notiert werden, um ihren Wert verwenden zu können. 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 einen numerischen Wert haben, 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 mithilfe von 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

Bei Termen, die eine Objektreferenz als Wert haben, kann es sich nur um Instanziierungen, Methodenaufrufe oder Variablen handeln. Mit Referenzen kann in Java nicht gerechnet werden, anders als z.B. in C. Instanziierungen haben noch die besondere Eigenschaft, dass sie aufgrund ihrer möglichen Gleichsetzung mit einem Methodenaufruf alleinstehend aufgerufen 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

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.

public int foo(int a, int b){
    return a * b + (b-a); //Gibt einen int als Ergebnis zurück
}

public void bar(){
    int x = foo(3, 8); //x wird der Wert 3 * 8 + (8 - 3) = 24 + 5 = 31 zugewiesen
    System.out.println(x); //Es wird die Zahl 31 ausgegeben
}

Ein Methodenaufruf kann auch alleinstehend verwendet werden.

Sollte eine Methode void als Rückgabetyp angeben, ist ein alleinstehender Aufruf unproblematisch.

Sollte eine Methode einen Wert zurückgeben, so gibt der Compiler bei einem alleinstehenden Aufruf die Warnung aus, dass das Ergebnis des Aufrufs verloren geht und vermutlich ein semantischer Fehler vorliegt.

public int foo(int a, int b){
    int result = a * b + (b-a);
    System.out.println("Result: "+result);
    return result;
}

public void bar(){
    foo(3, 8); //foo gibt einen int zurück, kann aber alleinstehend aufgerufen werden; Das Ergebnis geht jedoch verloren
    System.out.println("Return value of foo(2, 6): "+foo(2,6)); //Hier ist foo(2,6) Teil eines Terms, der zurückgegebene Wert wird also noch gebraucht
}

Die Ausgabe dir Methode bar ist:

Result: 31
Result: 16
Return value of foo(2, 6): 16

Der erste Aufruf von foo(3,8) wird vom Compiler mit einer Warnung markiert.