Skip to main content

Lassen wir Java rechnen – Die Rechenoperationen für Variablen

Ich liebe Mathe.

In der Biographie „Der Mann, der die Zahlen liebte“, stellt Paul Hoffmann das Mathematikgenie Paul Erdös vor.

Erdös war eines der größten Genies des 20 Jahrhunderts.

Er arbeitete mit zahlreichen Wissenschaftlern zusammen und verfasste durchschnittlich mehr Publikationen im Jahr, als andere Mathematiker im ganzen Leben.

Da Erdös sich mit sehr vielen Theoremen vergangener Mathematiker beschäftigte, geht der Autor auch auf deren Schaffen ein.

Dieses Buch liefert auf eine sehr anschauliche Art und Weise, wie mathematische Probleme gelöst werden.

Dabei wird Mathematik als reines Geisterexperiment beschrieben.

Zum Beispiel
Der Autor beschreibt sehr eindrucksvoll, wie Erdös stundenlang in einer Hotelempfangshalle saß und vor sich hinstarrte.

Nach stundenlangen Innehalten (alle Mitmenschen um ihn herum dachten er schläft), sprang er auf und rief:
„Es ist nicht Null. Es ist Eins.“

Mathematik ist eine Geistesübung, für welche man keine Labore und keine teuren Hilfsmittel benötigt.

Mathematik findet ausschließlich in der Gedankenwelt statt.
Vielleicht benötigt der Wissenschaftler ein Blatt Papier und einen Stift… Mehr aber nicht

Dieses Buch ist zwar als Biographie ausgeschildert.

Aber es ist Vielmehr als das.
Es ist eine Liebeserklärung an die Mathematik.

Das Rechnen mit Zahlen bietet dir in der Java Programmierung einen bedeutenden Einstieg.

Du kannst nämlich sehr schnell Programme erzeugen, welche auch etwas Wirkliches produzieren.

Du gibst zwei Zahlen ein und Java produziert etwas komplett Neues.

Oder wie es Aristoteles sagte:

Das Ganze ist mehr als die Summe seiner Teile.

Und um die Produktion von mathematischen Gleichungen, mit Hilfe von Java, geht es in diesem Beitrag.

Ich stelle dir die einzelnen Operationen der Java Programmierung vor.

Dann möchte ich mit dir einige Berechnungen durchführen.
Und zum Schluss schreiben wir noch Methoden, welche arithmetische Berechnungen durchführen.

Lass uns die beiden Sachgebiete Programmierung und Arithmetik jetzt verbinden.

Java nutzt diverse Operationszeichen um mathematische Berechnungen zu vollziehen.

Hier ist ein Überblick über alle Operationszeichen, welche du bei der Java Programmierung nutzen kannst.

Operator Operation
+ Addition
Subtraktion
* Multiplikation
/ Division
% Restwert


Den Plusoperator kennst du ja schon.

Dieser Operator ist überladen.

Das heißt.
Die Verwendungsmöglichkeiten des Operators sind vielseitig.
Du kannst diesen sowohl zur Addition, als auch zur Konkatenation verwenden.

Eine Konkatenation ist ein Verknüpfen von mehreren Textwerten zu einem Ganzen.
In einigen Artikeln habe ich dies zusammen mit der System.out.println()-Anweisungen verwendet.

Beispiel:


public class JavaRechnen{
public static void main (String [] args) {


System.out.println("Der Text"+" wird zusammengefasst.");//Der + Operator fügt beide Texte zusammen
}
}

Der Plusoperator summiert aber auch zwei Zahlen miteinander.


public class JavaRechnen{
public static void main (String [] args) {


System.out.println(17+4);//Der + Operator berechnet die Summe der beiden Zahlen.
}
}

Du kannst die beiden Zahlen auch in Variablen stecken und dann beide Werte miteinander addieren.


public class JavaRechnen{
public static void main (String [] args) {
int x= 15;
int y= 35;


System.out.println(x+y);//Der + Operator berechnet auch hier die Summe der beiden Zahlen.
}
}

Java bietet dir weiterhin die Möglichkeit eine Variable um einen bestimmten Wert zu erhöhen.


public class JavaRechnen{
public static void main (String [] args) {
int x= 15;
int y= 35;


System.out.println(x+50);//Jetzt wird der Wert der Variablen x um 50 erhöht.
}
}

Sobald du aber einen Textwert vor eine Berechnung stellst und dies auf der Konsole ausgeben möchtest, funktioniert das Ganze nicht mehr.

Jetzt wird nicht gerechnet

public class JavaRechnen{
public static void main (String [] args) {
int x= 15;
int y= 35;


System.out.println("Das Ergebnis ist: "+x+50);//Jetzt werden die Zahlen 15 und 50 als Textwert interpretiert.
}
}

Java interpretiert dann den ganzen Ausdruck als Konkatenation.

Aber du hast die Möglichkeit zum Klammern.
Setze deine Berechnungen in Klammern und verknüpfe dies über das Pluszeichen.

Jetzt wird gerechnet

public class JavaRechnen{
public static void main (String [] args) {
int x= 15;
int y= 35;


System.out.println("Das Ergebnis ist: "+(x+50));//Durch die Klammer weiß Java, dass hier gerechnet werden soll.
}
}

Sobald du sehr große Zahlen hast, kannst du diese ab Java 7 auch über Tausenderpunkte darstellen.

Nutze dafür den Unterstrich.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1_500;//Der Unterstrich für den Tausenderpunkt.
int y= 35;


System.out.println("Das Ergebnis ist: "+(x+50));
}
}

Sobald du Kommazahlen miteinander verrechnen möchtest, muss eine Zahl als Kommazahl ausgewiesen sein.

Java gibt dann das Ergebnis ebenfalls als Kommazahl zurück.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1_500;
int y= 35;


System.out.println("Das Ergebnis ist: "+(x+50.00));//Dadurch, dass ich 50.00 geschrieben habe, ist das Ergebnis ebenfalls eine Kommazahl.
}
}

Wenn du die Summe von Kommazahlen berechnen möchtest, muss mindestens eine Variable diesen Datentyp entsprechen.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1_500;
double y= 35.02;//Aus int wird double.


System.out.println("Das Ergebnis ist: "+(x+y));
}
}


Der Minusoperator funktioniert ähnlich

Der Minusoperator ist ebenfalls überladen.

Du kannst mit diesem negative Zahlen darstellen.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1_500;
double y= -35.02;//Nutze das Minuszeichen um negative Zahlen darzustellen


System.out.println("Das Ergebnis ist: "+(x+y));
}
}

Du kannst diesen auch zur Subtraktion verwenden.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1_500;
double y= -35.02;


System.out.println("Das Ergebnis ist: "+(x-y));//Mit dem Minuszeichen kannst du auch Werte subtrahieren.
}
}

Sobald du allerdings eine negative Zahl subtrahieren möchtest, solltest du die beiden Minuszeichen trennen.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1_500;
double y= -35.02;


System.out.println("Das Ergebnis ist: "+(15- -30));//Trennung durch Leerzeichen.
}
}


Die Division machst du über einen Schrägstrich.

Jetzt wird es spannender.

Denn jetzt landen wir im Bruchbereich.

Um einen Ergebnis als Bruch darzustellen, muss dieser den Datentyp float oder double entsprechen.

Wenn du zwei Integer Werte dividierst entspricht das Ergebnis immer einen Integer Datentypen.

Das funktioniert nicht.

public class JavaRechnen{
public static void main (String [] args) {
int x= 1;
int y= 3;


System.out.println("Das Ergebnis ist: "+(x/y));//Der Wert wird als Integerwert zurück gegeben.
}
}

In diesem Fall solltest du eine der Variablen als Gleitkommazahl deklarieren.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1;
float y= 3;


System.out.println("Das Ergebnis ist: "+(x/y));//Jetzt ist das Ergebnis eine Kommazahl.
}
}

Oder du castest das Ergebis.


public class JavaRechnen{
public static void main (String [] args) {
int x= 1;//Integerwert.
int y= 3;//Integerwert.


System.out.println("Das Ergebnis ist: "+((double) x/y));//Das Ergebnis ist ein double Datentyp.
}
}


Die Multiplikation machst du mit dem Stern.

Wie gehabt kannst du zwei Werte miteinander verrechnen.
Du kannst diese Werte natürlich auch in Variablen stecken.

Mehr gibt es eigentlich nicht zu sagen.


public class JavaRechnen{
public static void main (String [] args) {
int x= 12;//Integerwert.
int y= 34;//Integerwert.


System.out.println("Das Ergebnis ist: "+(x*y));//Multiplikation durch das Sternchen.
}
}


Das letzte Operationszeichen nennt sich Modulo.

Dies gibt dir den Rest einer Division zurück.

Zum Beispiel:
20 geteilt durch 2 wären 10. Rest 0
21 geteilt durch 2 wären 10. Rest 1.

Das Zeichen dafür entspricht dem Prozentzeichen.


public class JavaRechnen{
public static void main (String [] args) {
int x= 12;//Integerwert.
int y= 34;//Integerwert.


System.out.println("Das Ergebnis ist: "+(11 % 2));//Modulo über Prozentzeichen
}
}

Wozu brauchst du diese Operation?

Du kannst feststellen, ob eine Zahl durch eine bestimmte Zahl teilbar ist.
(Beispiel: Primzahlen)

Oder du kannst dir alle ungeraden und geraden Zahlen ausgeben lassen.
In einer grafischen Tabelle kannst du dann alle ungeraden Zeilen einfärben.

Du siehst dieser Operator hat seine Daseinsberechtigung.

Auch Java unterscheidet Punktrechnung vor Strichrechnung

Die Gesetze der Mathematik gelten auch hier.

3 mal 5 ist eigentlich nichts anderes als 5+5+5.
Somit ist 3+3*5 das Gleiche wie 3+5+5+5.

Und 10 geteilt durch 5 ist nichts anderes als 10-5-5.

Die Punktrechnung ergibt sich somit aus der Strichrechnung.
Und deshalb wird eine Multiplikation und eine Division immer zuerst berechnet.


public class JavaRechnen{
public static void main (String [] args) {
int x= 12;//Integerwert.
int y= 34;//Integerwert.


System.out.println("Das Ergebnis ist: "+(3+3*5));//Punktrechnung vor Strichrechnung
}
}

Wenn du eine Strichrechnung der Punktrechnung vorziehen möchtest, musst du klammern.


public class JavaRechnen{
public static void main (String [] args) {
int x= 12;//Integerwert.
int y= 34;//Integerwert.


System.out.println("Das Ergebnis ist: "+((3+3)*5));//zusätzliche Klammerung
}
}


Und so kannst du die einzelnen Berechnung in Methoden implementieren.

Ich baue einmal in die Klasse ein paar Methoden ein.

Diese rufe ich dann über die main-Methode auf.

Die Methoden heißen:

  • Addiere
  • Subtrahiere
  • Dividiere
  • Multipliziere
  • Bilde den Rest

Alle Methoden sollen beim Aufruf direkt zwei Parameter für die Berechnung übergeben bekommen.
Und alle Methoden sollen die Werte als Textantwort zurückgeben.

Und so geht’s.


public class JavaRechnen{
static void addiere(int summandEins, int summandZwei){
System.out.println("Die Summe aus "+summandEins+" und "+summandZwei+" ist "+(summandEins+summandZwei));
}


static void subtrahiere (int minuent, int subtrahent){
System.out.println("Die Differenz aus "+minuent+" minus "+subtrahent+" ist "+(minuent-subtrahent));
}


static void multipliziere (int faktorEins, int faktorZwei){
System.out.println("Das Produkt aus "+faktorEins+" und "+faktorZwei+" ist "+(faktorEins*faktorZwei));
}


static void dividiere (double divident, double devisor){
System.out.println("Der Quotient aus "+divident+" und "+devisor+" ist "+(divident/devisor));
}


static void bildeRest (int ausgangsZahl, int devisor){
System.out.println("Bei der Division aus "+ausgangsZahl+" und "+devisor+" entsteht ein Rest von "+(ausgangsZahl%devisor));
}


public static void main (String [] args) {
addiere(2,3);
subtrahiere(1118,9);
multipliziere(5,6);
dividiere(188,9);
bildeRest(122,7);
}
}

Cool oder?

Probiere doch mal die einzelnen Methoden separat mit verschieden Datentypen aus.

PS. Auch mit einem char lässt sich rechnen.

Zusammenfassung:

  • Java unterscheidet 5 Operationszeichen.
  • Mit diesen Operationszeichen lassen sich alle Grundrechenarten abbilden.
  • Java unterscheidet Punktrechnung vor Strichrechnung.
  • Bei der Berechnung solltest du stets den Datentyp im Auge behalten.
  • Sobald du einen Bruch als Ergebnis erwartest, setze float und double in deine Gleichungen ein.

Ähnliche Beiträge

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]

Java Vererbung – Die Hierarchien richtig planen

Java Vererbung Hierarchien

Java Vererbung hat nichts mit Biologie zu tun. Die Genetik besagt, dass bestimmte Merkmalsausprägungen von den Eltern auf die Kinder übergehen. Solche Merkmalsausprägungen sind: die Hautfarbe die Haarfarbe die spezifische Größe und weitere körperliche Merkmale. Und in Java – was ist da Vererbung? Lass es uns herausfinden. Was erwartet dich in diesem Beitrag? Zuerst schauen […]

Zwei smarte Möglichkeiten eine Java Zufallszahl zu erzeugen

Java Zufallszahl

Java Zufallszahl – Wieso? In der Java Programmierung benötigst du immer wieder einmal Zufallszahlen. Du möchtest deine Software mit Daten testen und dir keine Zahlen ausdenken. Du benötigst Stichproben, welche ein reales Verhalten simulieren. Du hast ein Spiel entworfen und die Akteure sollen mit zufälligen aber unterschiedlichen Größen, Rüstungsleveln usw. auftreten. Die Einsatzmöglichkeiten für Zufallszahlen […]

Das Java Leben ist einfacher mit For-Schleife

Java For Schleife Aufbau

In einem anderen Artikeln habe ich bereits über Schleifen in Java gesprochen. In diesem Artikel möchte ich dir eine ganz besondere Schleife vorstellen. Warum ist diese so toll? Sie hat einen integrierten Schleifenzähler. Die Schleife zählt also bei jedem Durchlauf automatisch mit. Aber dazu gleich mehr…. Lass uns einmal so eine For Schleife anlegen.

Du musst in Java nicht jede Exception fangen

Java Exception fangen

Kennst du die Metapher mit dem Jongleur und den Bällen? Ein Jongleur hält drei Bälle in der Luft, dann vier und irgendwann fünf. Aber irgendwann ist es genau ein Ball zu viel. Und Alles bricht zusammen. Ja ein Ball zu viel, kann alles versauen. 🙂 Und so ist es doch immer im Leben. Du kannst […]

Java lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

So kannst du deine Java Methoden ausführen

Java Methoden ausführen

Du hast die ersten Java Methoden erstellt. Doch wie greifst du jetzt auf diese zu? Wie kannst du diese Methoden in einer anderen Klassen aufrufen? Welcher Unterschied, hinsichtlich des Methodenaufrufes, besteht eigentlich zwischen deinen Java Methoden? Diese Fragen möchte ich gern in diesem Beitrag beantworten. Gehen wir dazu in den Garten und schauen uns Blumen […]

So verwendest du den Java Oder Operator

Java Oder Operator

Kennst du das auch aus deiner Schulzeit? Du schreibst eine Klassenarbeit in irgendeinem Fach. Nehmen wir einfach mal an – Mathe. Jetzt bist gerade fertig mit deiner Arbeit. Und zu Hause wirst du gefragt: „Und wie lief es?“ Du antwortet:“ Ganz gut. Es wird bestimmt eine Eins oder eine Zwei.“ Drei oder vier Tage später […]

Java Übung 11 – Java Objekte in Java Methoden übergeben

Java Übung Java Methoden Objekte

In dieser Java Übung möchte ich dir zeigen, dass du auch in Klassenmethoden auf Objekte und deren Instanzvariablen zugreifen kannst. Schau dir dazu einmal diesen Java Code an. public class Umwandlung { private int x; public int getX() { // getter Methode return x; } public void setX(int x) { // setter Methode this.x = […]

Beim Aufruf werden Java Methoden auf dem Stack gestapelt

Java Methoden gestapelt

Java Methoden werden beim Aufruf gestapelt. Und jedes Element auf dem Stapel nimmt Speicherplatz weg. Und manchmal ist es so, dass der Stapel richtig hoch wird und dann…. Ja was passiert eigentlich dann? Betrachten wir einmal ein Computerspiel. Irgendeines. In diesem Computerspiel gibt es Vögel, welche abgeschossen werden sollen. Was bedeutet das denn genau? Beim […]

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]