Vergleichs-, arithmetische und logische Operatoren!-Vergleichen, rechnen und verknüpfen.

Keylearnings:

• Was sind Operatoren?
• Was ist ein Vergleichsoperator?
• Was sind logische Operatoren?
• Wie kann man arithmetische Operatoren zum Rechnen verwenden?
• Was ist ein Inkrement bzw. Dekrement?
• Wie werden Operatoren in Java verwendet?

Liebst du das Backen auch so sehr?

Also ich liebe es!

Aber ich finde damit der Kuchen schmeckt, muss er auf jeden Fall zu 20% aus Zucker bestehen und in 100g Kuchen müssen mindestens fünf Rosinen oder zwei getrocknete Pflaumen enthalten sein.

Ach Mensch! Damit der Kuchen ein Erfolg wird, muss man an so vieles gleichzeitig denken.

Das ist genau wie beim Programmieren!

Da können wir uns wirklich glücklich schätzen, dass es die Operatoren gibt, die uns hierbei unterstützen.

Aber habe Geduld mein Freund! Lass uns die Sache systematisch angehen!

Ich hatte bereits hier versprochen, dass wir uns die Art wie Vergleiche und Bedingungen in Java ausgeführt und verknüpft werden im Detail ansehen.

Wir haben auch schon hier und hier Werte miteinander verglichen. In der Regel haben wir überprüft, ob ein bestimmter Zahlenwert (z.B. Franka’s Kontostand) kleiner oder größer als ein anderer Zahlenwert (z.B. Kosten für Franka’s Bohrmaschine) ist.

In Abhängigkeit hiervon haben wir dann unterschiedliche Bildschirmausgaben gemacht oder den Durchlauf einer Schleife unterbrochen.

Was ist ein Operator?

Mittelpunkt dieser Vergleiche waren immer Symbole wie == (für Gleichheit) oder < (für kleiner als). Und genau diese Symbole heißen Operatoren.

Natürlich gibt es neben den größer, kleiner und Gleichheitsoperatoren noch einige andere!

Grundsätzlich können wir die Operatoren in drei Kategorien einteilen.

1. Operatoren, mit denen wir zwei Dinge vergleichen können (z.B. ist Zahl a größer als Zahl b). Diese nennt der Fachmann Vergleichsoperatoren!
2. Operatoren, mit denen wir Bedingungen miteinander verknüpfen. Hier spricht der Fachmann von logischen Operatoren.
3. Operatoren, die wir auf Objekte (Fachchinesisch Operanden) anwenden können und dadurch ein neues Objekt erhalten. So ergibt beispielsweise die Addition der Zahl a zur Zahl b die neue Zahl c=a+b. Bei dieser Art von Operatoren spricht der Fachmann von arithmetischen Operatoren.

Lass uns mit den Vergleichsoperatoren beginnen!

Die Vergleichsoperatoren in Java

Bei den Vergleichsoperatoren sind immer zwei Werte beteiligt, die miteinander verglichen werden. Das Ergebnis eines Vergleiches ist ein Wahrheitswert.

Natürlich gibt es unterschiedliche Arten von Vergleichen. So kannst du z.B. überprüfen, ob zwei Variablen den gleichen Wert haben, oder ob ein Wert größer als ein anderer ist.

Aber weißt du was? Schau dir einfach folgende Tabelle an! Ich war fleißig und habe alle Vergleichsoperatoren und deren Funktion darin aufgelistet und beschrieben.

==	Gleichheit
!=	ungleich
<	kleiner als
<=	kleiner oder gleich als
>	größer als
>=	größer oder gleich als

In der Regel wirst du Operatoren innerhalb von Kontrollstrukturen wie der if..then..else oder der switch Anweisung verwenden.

Schauen wir uns das an einem einfachen Beispiel mal genauer an.

Wir hatten es ja bereits besprochen. Der Kuchen muss zu 20% aus Zucker bestehen!

1: double zuckerInProzent = 25;
2: if (zuckerInProzent >= 20){
3:	System.out.println("Yeah, das wird was!");
4: }else{
5:      System.out.println("Definitiv mehr Zucker!!");
6: }

Easy! Oder? War ja auch nur zum Aufwärmen! Also was machen wir hier?

Der wichtigste Teil! Zeile zwei!!!

Hier verwenden wir den „größer oder gleich als“ Vergleichsoperator im Bedingungsteil einer if..then..else Anweisung. Wir überprüfen hier, ob der Kuchen einen Zuckeranteil von 20 oder mehr Prozent besitzt.

Da wir die Variable zuckerInProzent mit dem Wert 25 initialisiert haben. Liefert der Vergleich zuckerInProzent >= 20 den Wahrheitswert true und die Anweisung in Zeile drei wird ausgeführt, welche die Bildschirmausgabe "Yeah, das wird was!" erzeugt.

Okay, erstmal so viel zu den Vergleichsoperatoren! Wenden wir uns den logischen Operatoren zu!

Die logischen Operatoren in Java

Vielleicht erinnerst du dich! Wir waren hier in der Situation eine Bedingung von mehr als einem Faktor abhängig zu machen.

So konnte sich Franka nur dann eine Bohrmaschine kaufen, wenn sie zum einen genug Geld auf dem Konto hatte und zum anderen die Bohrmaschine als Schnäppchen im Sonderangebot zu bekommen war.

Es sind also zwei Bedingungen zu überprüfen und anschließend gemeinsam auszuwerten gewesen und hierfür gibt es die logischen Operatoren UND und ODER.

&&	UND Verknüpfung von Bedingungen
||	ODER Verknüpfung von Bedingungen

Schauen wir uns das mal in der Praxis an!

Wir haben festgestellt, dass unser Kuchen nur dann gut ist, wenn er aus 20% Zucker UND  fünf Rosinen ODER zwei Pflaumen besteht.

Wir haben also drei Einzelbedingungen miteinander zu Verknüpfen.

Okay, was denkst du? Welche Ausgabe liefert folgendes Programm?

1:double zuckerInProzent = 25;
2:int anzahlRosinen = 4;
3:int anzahlPflaumen =3;
4:if ((zuckerInProzent >= 20) && 
             (anzahlRosinen >= 5) || (anzahlPflaumen >= 2)){
5:           System.out.println("Yeah, das wird was!");
6:}else{
7:	System.out.println("Pfui, das schmeckt noch nicht!");
8:}

Wieder ist der Bedingungsteil der if Anweisung in Zeile vier am wichtigsten. Hier werten wir die drei Bedingungen zuckerInProzent >= 20, anzahlRosinen >= 5 und anzahlPflaumen >= 2 aus und verknüpfen diese anschließend über die logischen Operatoren && (UND) und || (ODER).

Aufgrund der Initialisierungen der Variablen in den Zeilen eins bis drei. Sind die Bedingungen zuckerInProzent >= 20 und anzahlPflaumen >= 2 erfüllt. Nur der Vergleich anzahlRosinen >= 5 schlägt fehlt.

Okay! Dröseln wir das mal auf!

Zuerst musst du wissen, dass der UND Operator zuerst ausgewertet wird. Denn der UND Operator ist von höherer Priorität als der ODER Operator. Das ist so ähnlich wie bei der berühmten „Punkt- vor Strichrechnung“, die du aus dem Mathematik-Unterricht aus der Schule kennst.

Deshalb erfolgt die Überprüfung des Bedingungsteils in unserem Beispiel einfach von links nach rechts. Zuerst wird die Bedingung (zuckerInProzent >= 20), welche über den UND Operator mit der Bedingung (anzahlRosinen >= 5) verknüpft ist ausgewertet.

Da wir nur vier Rosinen verbacken haben und die UND Verknüpfung nur wahr ist, wenn beide Bedingungen erfüllt sind, ist die Bedingung (zuckerInProzent >= 20) && (anzahlRosinen >= 5) falsch.

Allerdings haben wir (zuckerInProzent >= 20) && (anzahlRosinen >= 5) über den ODER Operator mit der Bedingung (anzahlPflaumen >= 2) verknüpft, und weil wir sogar drei Pflaumen in unserem Kuchen verarbeitet haben, ist diese Bedingung erfüllt.

Eine ODER-Verknüpfung ist wahr sobald mindestens eine der Teilbedingungen erfüllt ist, deshalb ist der Bedingungsteil unserer if..then..else Anweisung erfüllt und die Ausgabe unseres Programms ist "Yeah, das wird was!".

UUUppps, ich glaube wir haben was falsch gemacht!

Was passiert wenn wir die Variable zuckerInProzent mit dem Wert 15 initialisieren?

Nach unserer Definition eines guten Kuchens sollte dann eigentlich die Meldung "Pfui, das schmeckt noch nicht!" ausgegeben werden.

Probier es mal aus!

Kim, irgendetwas ist schief gegangen! Ich erhalte noch immer die Meldung "Yeah, das wird was!".

Ja, ganz genau! Das Problem ist, dass im Bedingungsteil der if..then..else Anweisung der UND Operator als erstes ausgewertet wird. Hierdurch ist die Bedingung (zuckerInProzent >= 20) && (anzahlRosinen >= 5) || (anzahlPflaumen >= 2) auf jeden Fall immer wahr, sobald (anzahlPflaumen >= 2) erfüllt ist, d.h. mehr als zwei Pflaumen im Kuchen sind. Und zwar egal, ob ausreichend Zucker verarbeitet wurde.

Kim, was muss ich machen?

Wir müssen dafür sorgen, dass zuerst die ODER Verknüpfung (anzahlRosinen >= 5) || (anzahlPflaumen >= 2) ausgewertet wir und erst danach über den UND Operator verknüpft wird.

Das erreichen wir aber ganz einfach indem wir die Bedingung (anzahlRosinen >= 5) || (anzahlPflaumen >= 2) nochmal klammern. Schau dir mal folgenden Programmschnipsel an:

1: double zuckerInProzent = 15;
2: int anzahlRosinen = 4; 
3: int anzahlPflaumen =3;
4: if ((zuckerInProzent >= 20) && 
          ((anzahlRosinen >= 5) || (anzahlPflaumen >= 2))){
5:       System.out.println("Yeah, das wird was!");
6:}else{
7:       System.out.println("Pfui, das schmeckt noch nicht!");
8:}

Okay, ich gebe zu! Um den Unterschied zu unserem Programm von oben zu entdecken brauchst du eine Lupe!

Der erste Unterschied ist die Initialisierung des Zuckeranteils in Zeile eins. Wir backen hier einen schlechten Kuchen, der nicht genügend Zucker enthält.

Viel wichtiger ist aber der kleine aber feine Unterschied im Bedingungsteil der if..then..else Anweisung in Zeile vier. Hier umschließen wir die ODER Verknüpfung (anzahlRosinen >= 5) || (anzahlPflaumen >= 2) mit zwei runden Klammern.

Damit sorgst du dafür, dass dieser Teil der Bedingung in der if..then..else Anweisung, welche erfüllt ist, da wir sogar drei Pflaumen verarbeiten, zuerst ausgewertet wird. Als nächstes verknüpfen wir das ganze dann über den UND Operator mit der Bedingung zuckerInProzent >= 20.

Da wir unseren Kuchen aber nur mit 15 Prozent Zucker backen ergibt das den Wahrheitswert FALSE. Der Bedingungsteil in der if Anweisung ist also nicht erfüllt und die Programmausgabe ist "Pfui, das schmeckt noch nicht!".

Okay, so viel zu den logischen Operatoren. Wenden wir uns als letztes den arithmetischen Operatoren zu.

Die arithmetischen Operatoren in Java

Die arithmetischen Operatoren benötigst du in Java immer dann, wenn es ums Rechnen geht. Einzigste Ausnahme hierbei sind die Zeichenketten. Aber dieser Thematik wittmen wir uns nochmal in einem eigenen Artikel.

Wieder war ich fleißig und habe alle arithmetischen Operatoren in folgender Tabelle aufgelistet.

+	Operator für die Addition
–	Operator für die Subtraktion
*	Operator für die Multiplikation
/	Operator für die Division
%	Division mit Rest
++	Inkrement
—	Dekrement

Die ersten vier Operatoren kennst du sicherlich aus der Grundschule. Aber lass uns dennoch mal ein Beispiel ansehen, denn hier gibt es eine böse Falle!!

1: int a = 4;
2: int b = 1;
3: double e = (a-b)/5;
4: System.out.println(e);

Komm schon! Kram den Taschenrechner hervor!! Was ist das Ergebnis?

Okay, ich sags dir! Das Ergebnis ist BÄÄÄM! Haargenau 0.0!

Häh? Was soll das Kim?

Wie? Behauptet dein Taschenrechner etwa was anderes? Okay, meiner auch!

Also, wo liegt der Hase begraben?

Mein Taschenrechner liefert das offensichtlich richtige Ergebnis (a-b)/5=(4-1)/5 = 0,6.

Na toll! Das bedeutet wir haben Bockmist gebaut!

Erkennst du das Problem?

Richtig! Das Problem sind die Datentypen!

In den Zeilen eins und zwei weisen wir den Integer-Variablen a und b zwar, wie es sich gehört, ganze Zahlen zu (ansonsten wäre es auch zu einem Kompilierungsfehler gekommen).

Allerdings ergibt die Division einer ganzen Zahl durch eine andere ganze Zahl (d.h. die Division zweier Integer) nicht wieder einen ganzzahligen Integer-Wert.

Da wir den arithmetischen Operator aber auf den Integerwert (a-b)=(4-1)=3 anwenden und ein Integer-Wert aufgrund seiner DNA keine Nachkommastellen kennt, werden diese einfach radikal abgeschnitten. Und so wird dann aus 0.6 der Wert null.

Wie wird es also richtig gemacht?

Ganz einfach! Die Variablen a und b dürfen nicht vom Typ Integer sein. Um eine Dezimalzahl zu speichern benötigen wir den Datentyp double. Wir ändern also einfach die Zeilen eins bis drei entsprechend.

1: double a = 4;
2: double b = 1;
3: double e = (a-b)/5;
4: System.out.println(e);

Jetzt ist das Programm der gleichen Meinung wie dein Taschenrechner. Die Programmausgabe ist 0.6.

Da die Variablen a und b jetzt vom Datentyp double sind, ist das Ergebnis des arithmetischen Operators / für die Divsion jetzt ebenfalls vom Typ double also eine Dezimalzahl.

Also merke: Obwohl wir in unserer Rechnung nur Integerwerte verwenden, kann bei der Division das Ergebnis vom Typ double sein. Das ist eine böse Fehlerquelle, auf die du unbedingt achten musst.

Was ist ein Inkrement bzw. Dekrement?

Häufig müssen wir einen Wert um eins erhöhen oder verringern. So wie wir es schon hier bei den Kontrollstrukturen gemacht haben.

Jetzt wirst du sicher sagen: „Och, das ist einfach. Das machen wir so!“

1: int i = 1;
2: int j = 3;
3: i = i+1;
4: j = j-1; 

Yeah man! You are so right! Super, dass du so schnell lernst!

Mit diesem Programmcode erhöhst du die Variable i auf zwei und verringerst den Wert von j um eins. Also von drei auf zwei.

ABER! Wenn du ein großer Programmierer werden willst, dann solltest du es dir zur Gewohnheit machen ein Inkrememt bzw. Dekrement zu verwenden. Und das geht so!

Möchtest du die Variable i um den Wert eins erhöhen, dann schreib einfach anstatt von i=i+1 die Kurzfassung i++.

Ähnlich sieht die Situation beim Dekrement aus! Du musst hier einfach die Langversion i=i-1 durch die Kurzversion mit dem Inkrement- Operator ersetzen. Du schreibst also einfach i--.

Lass uns die neu gewonnenen Erkentnisse gleich auf unser Beispielprogramm von oben anwenden!

Unter Einsatz des Dekrements bzw. Inkrements, sieht das ganze dann folgendermaßen aus:

1: int i = 1;
2: int j = 3;
3: i++;
4: j--; 

Das Programm funktioniert haargenau wie das Programm von oben!

Auch hier wird die Variable i in Zeile drei um eins auf den Wert zwei erhöht. In Zeile vier findet dann ein Dekrement auf die Variable j statt wodurch j auf den Wert zwei reduziert wird .

Ach übrigens das Inkrement bzw. das Dekrement ist nicht auf Integer-Werte beschränkt. Du kannst diese genauso gut auch für Variablen vom Datentyp double verwenden.

ATTENTION PLEASE!!

Präinkrement und Postinkrement in Java

Wir haben in unserem Beispiel den Inkrement-Operator ++ immer hinter die Variable geschrieben, also i++.

Aber auch ++i ist zulässig.

Hat das die gleiche Bedeutung? JEIN!!

In unserem Beispiel hätte das keinen Unterschied gemacht. Allerdings musst du höllisch aufpassen, wenn du ein Dekrement und eine Zuweisung gleichzeitig verwendest. Wirf mal ein Auge auf folgenden Programmschnipsel!

1: int i = 1;
2: int j = 1;
3: int a,b;
4: a= i++;
5: b= ++j;

Kannst du mir verraten, welche Werte die Variablen a und b haben?

Okay, ich verrate es dir!

Die Variable a hat den Wert eins und b den Wert zwei und das obwohl i und j nach Ablauf des Programms beide den Wert zwei haben.

Hmm, wie kann das angehen?

Nun! Wenn wir i++ schreiben, dann weisen wir zuerst den Wert aus i der Variablen a zu und erhöhen erst anschließend um eins.

In Zeile fünf machen wir es hingegen umgekehrt. Indem wir das Inkrement (++j) vor die Variable j schreiben, sorgen wir dafür, dass j zuerst um eins erhöht wird und erst danach die Zuweisung an b ausgeführt wird.

Das führt dann im Endergebnis dazu, dass die Variablen a und b unterschiedlich sind, obwohl i und j auch am Ende des Programms die gleichen Werte haben.

Hierbei sprechen wir von einem Präinkrement, wenn der Inkrementoperator vor der Variablen (++j) steht und von einem Postinkrement (i++) wenn dieser erst nach der Variablen folgt.

Gleiches gilt natürlich auch für den Dekrement-Operator.

Division mit Rest

Bleibt noch die Division mit Rest zu erklären, für welche der arithmetische Operator % zur Verfügung steht.

Wir hatten bereits festgestellt, dass die Division zweier Integer Zahlen als Ergebnis nicht notwendig wieder eine Zahl vom Typ Integer ist.

Aber zum Glück erinnere ich mich noch an Frau Gube. Frau Gube war meine Mathematik-Lehrerin und hat mich in die Geheimnisse der Division mit Rest eingeführt.

Ich erinnere mich noch gut! Es ging so!! Wir haben fünf Kuchenstücke, die wir an drei Leute verteilen möchten.

Um dabei gerecht zu bleiben bekommt jeder ein ganzes Stück und zwei Stücke Kuchen bleiben übrig. Und genau das liefert uns der Operator % zurück. Es ist 5%3=2.

Okay, Kim und wofür kann ich die Division mit Rest gebrauchen?

Öhm, frag Frau Gube! 🙂

Aber schauen wir uns das ganze mal konkret an.

1: int anzahlKuchen = 5;
2: int anzahlPersonen = 3;
3: int e = anzahlKuchen%anzahlPersonen; 
4: System.out.println(e);

Na, kannst du erraten was das Ergebnis ist?

In Zeile eins speichern wir die Kuchenanzahl in der Variablen anzahlKuchen und in der zweiten Zeile die Anzahl der Personen in der Variablen anzahlPersonen.

Richtig interessant ist Zeile drei! Hier wird der arithmetische Operator % auf die Werte in anzahlKuchen und anzahlPersonen angewendet.

Da wir fünf Stücke Kuchen gebacken haben und diese auf drei Personen verteilen wollen, ist das Ergebnis der Division mit Rest gleich 2.

Das Ergebnis speichern wir in der Variablen e und geben es in Zeile 4 auf dem Bildschirm aus!

So das waren sie! Die wichtigsten Vergleichsoperatoren, logischen Operatoren und arithmetischen Operatoren. Es gibt noch ein paar andere, welche allerdings in einem Einführungsartikel den Rahmen sprengen würden.

Wie immer freue ich mich über deine Fragen im Kommentarbereich!

Hat dir Artikel gefallen?

Über dein Like auf Facebook freue ich mich wie Hölle!