Java-Grundlagen: Arithmetische Operatoren in Java

In Java sind 11 arithmetische Operatoren implementiert. Alle arithmetischen Operatoren erwarten numerische Operanden. Dabei ist es möglich integrale und Gleitkomma-Datentypen als Operanden zu verwenden.

Die unterschiedlichen Datentypen können auch in einem arithmetischen Ausdruck zusammen verwendet.

Dabei wird immer der kleinere Datentyp in den größeren Datentyp mit Hilfe einer erweiternden Typumwandlung konvertiert.

So wird bspw. bei einer Addition eines int-Operanden und eines double-Operanden zuerst der int-Operand in einen double-Operand umgewandelt und anschließend die Addition durchgeführt.

Der Rückgabewert arithmetischer Operatoren ergibt sich aus den verwendeten Operanden. Bei Operanden unterschiedlichen Datentyps entspricht der Datentyp des Rückgabewerts immer dem des größeren Operanden-Datentyps. Die Reihenfolge der numerischen Datentypen wird in dem Beitrag: Typumwandlung bzw. Typkonvertierung in Java beschrieben.

---

Unser großes
Android Online-Kurs
Gesamtpaket

---

Ideal für den praxisnahen Einstieg in die Entwicklung von Android Apps Besonders einsteigerfreundlich - jeder Arbeitsschritt ist exakt dokumentiert Enthält alle 35 Lektionen unseres Android Apps Programmieren Kurses Enthält alle 8 Lektionen unseres SQLite Datenbank App Programmieren Kurses

---

Weitere Infos

---

In Ausdrücken können Java-Operatoren mehrere Argumente zugewiesen werden. Die mögliche Anzahl ist durch die Stelligkeit des Operators vorgegeben, diese gibt an wie viele Argumente er benötigt.

Bei arithmetischen Operatoren unterscheidet man dabei:

• Einstellige Operatoren – Wie das positive und negative Vorzeichen sowie die Inkrement- und Dekrementoperatoren mit Nebeneffekt.
• Zweistellige Operatoren – Die arithmetischen Operatoren, für die Addition, Subtraktion, Multiplikation oder Division sowie dem Restwertoperator.

Die folgende Tabelle stellt die arithmetischen Operatoren von Java einzeln vor:

In dem folgenden Beispielprogramm werden die arithmetischen Operatoren verwendet.

In dem ersten Teil des Quelltextes werden arithmetischen Operatoren der Reihe nach vorgestellt. Es wird für jeden Operator ein Beispiel für ganzzahlige Operanden und eines für Gleitkomma-Operanden angegeben.

Im zweiten Teil des Quelltextes, ab Zeile 79, werden einige Experimente mit arithmetischen Ausdrücken durchgeführt. Dabei sollen zukünftige Java-Programmierer sensibilisiert werden für die Themen Typumwandlung und Überschreitung des Wertebereichs.

Beispiel arithmetische Operatoren in Java.

/*
* Beispielanwendung arithmetische Operatoren in Java.
*/

public class ArithmetischeOperatoren{
 public static void main(String[] args) {
 
  byte  aB = 9,    bB = 4,    ergebnisB;
  float aF = 9.9F, bF = 4.5F, ergebnisF;

  System.out.println("\naB = " + aB + "     aF = " + aF);
  System.out.println("bB = " + bB + "     bF = " + bF);

  ergebnisB = (byte) (aB + bB);
  ergebnisF = aF + bF;

  System.out.println("\nAddition (ganzzahlig): aB + bB = " + ergebnisB);
  System.out.println("Addition (Gleitkommazahl): aF + bF = " + ergebnisF);    

  ergebnisB = (byte) (aB - bB);
  ergebnisF = aF - bF;

  System.out.println("\nSubtraktion (ganzz.): aB - bB = " + ergebnisB);
  System.out.println("Subtraktion (Gleitk.): aF - bF = " + ergebnisF); 

  ergebnisB = (byte) (aB * bB);
  ergebnisF = aF * bF;

  System.out.println("\nMultiplikation (ganzz.): aB * bB = " + ergebnisB);
  System.out.println("Multiplikation (Gleitk.): aF * bF = " + ergebnisF); 

  ergebnisB = (byte) (aB / bB);
  ergebnisF = aF / bF;

  System.out.println("\nDivision (ganzz.): aB / bB = " + ergebnisB);
  System.out.println("Division (Gleitk.): aF / bF = " + ergebnisF); 

  ergebnisB = (byte) (aB % bB);
  ergebnisF = aF % bF;

  System.out.println("\nDivision mit Rest (ganzz.): aB % bB = " + ergebnisB);
  System.out.println("Division mit Rest (Gleitk.): aF % bF = " + ergebnisF); 

  ergebnisB = (byte) (aB * ++bB);
  ergebnisF = aF * ++bF;

  System.out.println("\nPraeinkrement (ganzz.): aB * ++bB = " + ergebnisB);
  System.out.println("Praeinkrement (Gleitk.): aF * ++bF = " + ergebnisF);
  System.out.println("bB = " + bB + "     bF = " + bF);

  bB = 4;
  bF = 4.5F;
  ergebnisB = (byte) (aB * bB++);
  ergebnisF = aF * bF++;

  System.out.println("\nPostinkrement (ganzz.): aB * bB++ = " + ergebnisB);
  System.out.println("Postinkrement (Gleitk.): aF * bF++ = " + ergebnisF);
  System.out.println("bB = " + bB + "     bF = " + bF);

  bB = 4;
  bF = 4.5F;
  ergebnisB = (byte) (aB * --bB);
  ergebnisF = aF * --bF;

  System.out.println("\nPraedekrement (ganzz.): aB * --bB = " + ergebnisB);
  System.out.println("Praedekrement (Gleitk.): aF * --bF = " + ergebnisF);
  System.out.println("bB = " + bB + "     bF = " + bF);

  bB = 4;
  bF = 4.5F;
  ergebnisB = (byte) (aB * bB--);
  ergebnisF = aF * bF--;

  System.out.println("\nPostdekrement (ganzz.): aB * bB-- = " + ergebnisB);
  System.out.println("Postdekrement (Gleitk.): aF * bF-- = " + ergebnisF);
  System.out.println("bB = " + bB + "     bF = " + bF);


  System.out.println("\n\n-\nExperimente mit arithmetischen Operatoren\n-");

  aB = 127;
  bB = 127;
  //short wS = (short) aB + (short) bB; // Compiler-Fehler: Loss of Precision
  short zS = (short) (aB + bB);
  //short yS = aB + bB; // Compiler-Fehler: Loss of Precision

  System.out.println("\naB = " + aB + "     bB = " + bB); 
  System.out.println("Addition (short): zS = (short) (aB + bB) = " + zS);

  long aL = 90000000000L;
  long zL = aL + aL;

  System.out.println("\naL = " + aL);
  System.out.println("zL = aL + aL = " + zL);

  int aI = 2147483647;
  int bI = (int) (Math.pow(2, 31) - 1);
  int zI = aI + bI;
  long cL = aI + bI;
  long dL = (long) (aI + bI);
  long eL = (long) aI + (long) bI;

  System.out.println("\naI = " + aI + "     bI = " + bI);
  System.out.println("Addition (int): zI = aI + bI = " + zI);
  System.out.println("Addition (long): cL = aI + bI = " + cL); 
  System.out.println("Addition (long): dL = (long) (aI + bI) = " + dL);
  System.out.println("Addition (long): eL = (long) aI + (long) bI = " + eL);

  aF = 340000000000000000000000000000000000000F;
  bF = 3.4E38F;
  float zF    = aF + bF;
  double zD   = aF + bF;
  double zzD  = (double) aF + (double) bF;

  System.out.println("\naF = " + aF + "     bF = " + bF);
  System.out.println("Add. (float) : zF  = aF + bF = " + zF);
  System.out.println("Add. (double): zD  = aF + bF = " + zD);
  System.out.println("Add. (double): zzD = (double)aF + (double)bF = " + zzD);
 }
}

Die meisten Ausdrücke im oberen Quelltext sind selbsterklärend. Es werden immer die Variablen aB, aF, bB und bF als Operanden mit verschiedenen arithmetischen Operatoren benutzt. Die zugehörige Textausgabe ist in der weiter unten abgebildeten Kommandozeilenausgabe dargestellt.

Besonders aufpassen müssen Programmierer, wenn die arithmetischen Operatoren auf ganzzahlige Operanden angewendet werden. Dabei wird für Operanden des Datentyps byte, short und int die Berechnung so ausgeführt, als würde es sich um int-Operanden handeln. Daher ist eine anschließendes Typumwandlung des Ergebnisses auf den benötigten Zieldatentyp notwendig. Siehe Zeile 81 bis 107.

Bei long-Operanden findet die Berechnung mit long-Datentypen statt, so dass keine Typumwandlung notwendig ist.

Werden Gleitkommazahlen verwendet, wird die Berechnung im Datentyp der Operanden durchgeführt. Also float oder double. Möchte man zwei float-Operanden addieren und das Ergebnis in einer double-Variable speichern, muss man bei Überschreitung des float-Wertebereichs jeweils eine explizite Typkonvertierung durchführen, damit die Berechnung im größeren double-Wertebereich stattfinden kann. Siehe Zeile 109 bis 118.

In der unteren Abbildung ist die Kommandozeilen Ausgabe zu der oberen Beispielanwendung dargestellt.

Arithmetische Operatoren in Java – Ausgabe der Beispielanwendung