Java Programm rechnen lassen: Rechenoperationen für Variablen im Überblick
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.
Inhalt
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.
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.
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.
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.
Über den Autor
