➗ Operatoren und Rechnen

Nun kennen Sie bereits Variablen und Datentypen um Informationen in Java festzuhalten. Informationen sind jedoch nicht viel Wert, wenn damit nicht gearbeitet werden kann.

Dazu dienen nun die Operatoren. Diese kennen Sie bereits aus der Mathematik. Damit lassen sich Variablen verändern, vergleichen und berechnen.

🎯 Ziele

• Sie wissen was Operatoren sind
• Sie können mit Variablen rechnen
• Sie können Variablen vergleichen und Bedingungen formulieren

💻 Open in Browser | 💾 download PDF

Zuweisungsoperator =

Der elementarste Operator ist der Zuweisungsoperator =. Mit diesem wir einer Variable einen Wert zugewiesen.

• Die Variable steht immer links, der zuzuweisende Wert immer rechts.
• Der zuzuweisende Wert kann sich wiederum in einer Variable oder Methode befinden.

   int sinnDesLebens = 42;
   int number        = sinnDesLebens;
//                   ^ Zuweisungsoperator

Arithmetische Operatoren +, -, /, *, %

Arithmetische Operatoren kennt Ihr bereits von der Mathematik. Damit lassen sich die gängigen Mathematischen Operationen durchführen. Neu ist einzig der Rest Operator %. Dieser dividiert eine Zahl und gibt den Rest zurück.

+ - / * % Arithmetische Operatoren

int result;
int number = 9;
int anotherNumber = 3;

result = number + anotherNumber; // Addition
result = number - anotherNumber; // Subtraktion
result = number / anotherNumber; // Division
result = number * anotherNumber; // Multiplikation
result = number % anotherNumber; // Rest der Division

Gerade/Ungerade berechnen mit %

Der Rest-Operator % gibt bei einer division immer den Rest zurück. Wenn man nun eine Division durch 2 durchführt lässt sich herausfinden ob eine Zahl gerade oder ungerade ist.

9 % 2  // ergibt 4 * 2 Rest 1 also ungerade
10 % 2 // ergibt 5 * 2 Rest 0 also gerade

public boolean even(int number) {
    return number % 2 == 0;
}

🖊 A1: Noten berechnen

Erstellen Sie ein Programm, welches vom Benutzer

• drei Semesternoten einliest (StdInput.read...)
• den Durchschnitt berechnet
• sich dabei an ein strenges Notensystem hält, dass nur ganze Noten zulässt und immer abrundet
• den Durchschnitt ausgibt

note

• Anhand dieser Übung erkennen Sie, dass man mit Variablen und Zahlen ganz normal rechnen kann.
• Auch sollte nun das EVA-Prinzip klar werden

Musterlösung

Wo ist die Methode main?

• Die Klasse mit der main Methode müsst Ihr selber erstellen.
• der import gehört ganz oben ins File.
• ... kann man löschen ;)

Musterlösung ohne main

import mytools.StdInput;

...

// deklarieren
double grade1;
double grade2;
double grade3;
double result;

// E - Einlesen
System.out.println("Welcome to the average calculator");
System.out.println("Please enter the first grade");
grade1 = StdInput.readDouble();
System.out.println("Please enter the second grade");
grade2 = StdInput.readDouble();
System.out.println("Please enter the third grade");
grade3 = StdInput.readDouble();

// V - Verarbeiten
result = (grade1 + grade2 + grade3) / 3;

// A - Ausgeben
System.out.println("The average grade is: " + result);

---

Themen ab hier sind erst in späteren Wochen relevant und werden bei

bedarf referenziert

Verkürzte arithmetische Operation mit sich selbst +=, -=, *=, /=

Oft möchte man den Wert einer Variablen direkt verändern. Das Resultat also nicht in eine neue Variable, sonder in sich selber speichern. Gegeben ist z.B. die Variable number vom Typ int mit dem Initialwert 3.

int number = 3;

Möchte man dieser Variable 4 hinzuaddieren geht das folgendermassen:

number = number + 4; // Addition und Zuweisung zu sich selbst

Da dies sehr oft vorkommt ist in allen gängigen Programmiersprachen dafür ein kombinierten Operator vorgesehen. Es wird dem Zuweisungsoperator den arithmetische Operator vorangestellt.

number += 4; // Verkürzte Addition und Zuweisung zu sich selbst

Aus number = number + 4; wird somit number += 4; und erspart uns die Dopplung der Variable. Dies geht natürlich auch für alle anderen arithmetischen Operatoren.

number -= 7; // Subtraktion und Zuweisung zu sich selbst
number *= 9; // Multiplikation und Zuweisung zu sich selbst
number /= 2; // Division und Zuweisung zu sich selbst

Unäre (einstellige) Operatoren ++, --

Noch häufiger als die verkürzte arithmetische Operation mit sich selbst wird im Programmieren schrittweise hoch und runtergezählt was auch Iteration genannt wird.

Möchte man also von 0 - 3 hochzählen geht dies so:

int number = 0;
number += 1;
number += 1;
number += 1;

Der Unäre Operator ++ zählt der links vorangestellten Variable eines nummerischen Typ eine 1 hinzu. Der obere Code ist somit identisch zu diesem:

int number = 0;
number++;
number++;
number++;

Unär => einstellig

Unär bedeutet einstellig, es braucht daher nur der linke und nicht auch einen rechten Teil beim Operator.

Funfact

C++ erweitert die Programmiersprache C. Um diese Verwandtschaft ein bisschen NERDisch Auszudrücken wurde das Wortspiel C++ gewählt. C++ ist eine weitere Iteration von C.

⚖️ Vergleichsoperatoren

• ==, !=, <, >, <=, >= und die Negation !

Vergleichsoperatoren ergeben immer einen boolean (true/false). Sie werden in Kontrollstrukturen als Bedingungen verwendet.

== Gleichheit

true  == true; // true
1     == 1     // true

false == true; // false
1     == 2     // false

!= Ungleichheit

false != true; // true
1     != 2     // true

true  != true; // false
1     != 1     // false

< Kleiner als

1 < 2 // true

2 < 1 // false
1 < 1 // false

> Grösser als

2 > 1 // true

1 > 2 // false
2 > 2 // false

>=Grösser gleich

2 >= 1 // true
2 >= 2 // true

1 >= 2 // false

<= Kleiner gleich

1 <= 2 // true
1 <= 1 // true

2 <= 1 // false

Negation

! Negation

!false // true
!(1 == 2) // true

!true // false
!(1 == 1) // false

Strings vergleichen

• String Variablen immer mit .equals() vergleichen, nie mit ==
  • ❗ Mit einem ! kann es Negiert werden. !"text".equals("text")
• Auch ist es gute Praxis der bekannte Wert mit dem unbekannten zu vergleichen und nicht anders rum:
  • ✅ "auto".equals(vehicle);
  • ❌ vehicle.equals("auto"); ergibt ein NullPointer wenn die vehicle den Wert null besitzt.