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

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.

So kannst du ein Java Programm starten und Argumente übergeben

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was ist aber vor der main-Methode. […]

Die mathematischen Grundlagen des Dezimalsystems für Java Programmierer

Java Dezimalsystem Mathematik Programmierer

Bei der Java Programmierung benötigst du Kenntnisse über das Dezimalsystem. Allein schon für die technische Umsetzung beim Runden einer Zahl. Oder du möchtest den Kehrwert bzw. den Umkehrwert einer Zahl im Programm bestimmen lassen. Aber auch für das Herausfinden des Stellenwertes – also wieviel Stellen hat eine Zahl – benötigst du das Grundwissen des Dezimalsystems. […]

Ende vom Java Blog?

Falls du hier schon länger dabei bist, wird dir aufgefallen sein – dass kaum noch Beiträge veröffentlicht werden. Das tut mir wirklich leid und dafür möchte ich mich auch entschuldigen. Ich weiß, dass Einige unter Euch den Java-Blog wirklich lieben. Aber es ist verdammt schwierig so ein aufwendiges Thema – stilvoll, unterhaltend und methodisch umzusetzen. […]

So kannst du Java Konstruktoren anlegen und überladen

Java Konstruktoren

Der Name sagt es schon. Java Konstruktoren konstruieren oder bauen Java Objekte. Und diese Objekte baut der Konstruktor auf Vorlage der entsprechenden Java Klasse. In diesem Beitrag zeige ich dir natürlich verschiedene Ansätze wie du den Konstruktor einsetzt. Ich zeige dir dies Schritt für Schritt. Dabei zeige ich dir auch verschiedene Dinge, welche nicht funktionieren. […]

Java Duales Zahlensystem – Binäre Zahlen in Java umwandeln

Java Dual System

Das duale Zahlensystem hat viele Bezeichnungen. Oft wird auch es Dualsystem oder Binärsystem genannt. Es besteht aber immer aus 2 Zahlen. Man verwendet oft die Zahlen 0 und 1. Es können aber auch sämtliche anderen Zahlenpaare sein. Zum Beispiel 7 und 175 sind für sich genommen, auch ein normales Zahlenpaar und somit ein Dualsystem. Mit […]

Java Objekte leben auf dem Heap

Java-Objekte-Heap

Java hat eine interne Speicherverwaltung. Eigentlich ist es nicht nur eine. Es sind mehrere.   Uns interessieren nur zwei. Methoden und lokale Variablen werden auf dem Stack verwaltet. Und die Speicherverwaltung für Java Objekte und den Instanzvariablen findet auf dem Heap statt.   Ja wieso braucht Java eigentlich zwei Speichersysteme?   Es ist ganz einfach. […]

Lexikalik, Syntax und Semantik in Programmiersprachen

Programmiersprachen Semantik Programmiersprachen Syntax Programmiersprachen Lexikalik Java

Java ist eine Programmiersprache. Und wie jede andere Programmiersprache ist auch Java, lediglich eine künstliche Sprache.   Normalerweise bieten künstliche Projekte immer jede Menge Spielraum für Eigenkreationen. Bei der Programmierung ist dies nicht ganz so. Denn Programmiersprachen sind auch immer sehr exakt.   Jede Programmiersprache und auch jede gesprochene Sprache folgt immer einer Abstraktionsreihenfolge, welche […]

Das Instanzieren von Java Klassen verhindern

Java Objekte Instanzieren verhindern

Die Instanzierung von Java Klassen verhindern. Was heißt das? Instanzen sind die Objekte einer Java Klasse. Und Instanzieren oder Instanzierung heißt nichts anderes, als Objekterstellung. Aber was soll das? Oder mal anders gefragt: Wieso sollte man verhindern, dass eine Java Klasse – Objekte erstellen kann? Schließlich sind doch Objekte der Sinn und Zweck jeder objektorientierten […]