Archiv für Java Basics

if-else-Anfragen für Fortgeschrittene

Nachdem wir hier die ersten Schritte mit if-else-Anfragen gelernt haben, wollen wir uns if-else-Anfragen quasi für Fortgeschrittene anschauen.

Es gibt in der Informatik die s.g. logischen Operatoren, zwei davon wollen uns für die kommenden Beispiele anschauen:

  • das „Logische-Und“, in Zeichen: &&
  • und das „Logische-Oder“, in Zeichen: ||

Man braucht natürlich zwei Variablen, um eine und-, bzw. oder-Verknüpfung zu machen. Diese werden nachfolgend mit Var1, bzw. Var2 betitelt:

Logisches-Und &&
+---------------------------------+
| Var1   | Var2   | Ergebnis (&&) |
+---------------------------------+
| true   | true   | true          |
| true   | false  | false         |
| false  | true   | false         |
| false  | false  | false         |
+---------------------------------+

Logisches-Oder ||
+---------------------------------+
| Var1   | Var2   | Ergebnis (||) |
+---------------------------------+
| true   | true   | true          |
| true   | false  | true          |
| false  | true   | true          |
| false  | false  | false         |
+---------------------------------+

Nun hierzu noch ein kleines Beispiel:

public class IfElseFortgeschrittene {

	public static void main(String[] args) {
		
		boolean bedingung1 = false;
		boolean bedingung2 = true;
			
		// und-Operator &&
		if (bedingung1 && bedingung2) {
			System.out.println("bedingung1 und (!) bedingung2 ist wahr!");
		} else {
			System.out.println("entweder ist eine der beiden Bedingungen falsch, oder beide!");
		}
		
		// oder-Operator ||
		if (bedingung1 || bedingung2) {
			System.out.println("bedingung1 oder (!) bedingung2 ist wahr");
		} else {
			System.out.println("weder bedingung1, noch bedinung2 ist wahr => also sind beide falsch!");
		}
	}
}

Die Ausgabe ist wie erwartet:

entweder ist eine der beiden Bedingungen falsch, oder beide!
bedingung1 oder (!) bedingung2 ist wahr

Wenn man ein bisschen mit den Werten experementiert, wird einem schnell klar, wie die beiden Operatoren funktionieren…!

P.S.: selbstverständlich kann man diese Operatoren beliebig tief verschachteln:

if ((bedingung1) || (bedingung2 && bedingung3)) {
  // ...
} else {
  // ...
}

if-else-Anfragen für Fortgeschrittene II

Für eine simple if-else-Anweisung gibt es in Java eine Kurzschreibweise. Diese sieht so aus:

<Bedingung> ? <Ausdruck1> : <Ausdruck2>
  • Ausdruck1 ist der Rückgabewert, falls die Bedingung wahr ist.
  • Ausdruck2, falls die Bedingung falsch ist.

Dieses Beispiel

	public static void main(String[] args) {
		
		int x = -5;
		
		int y = (x<0) ? -x : x;
		
		System.out.println(y);
	}

ist gleichwertig mit der „normalen“ Schreibweise

	public static void main(String[] args) {

		int x = -5;
		
		// zunächst leer
		int y;
		
		if (x<0) {
			y = -x;
		} else {
			y = x;
		}
		
		System.out.println(y);
	}

Beide Beispiele kehren vor der Zuweisung an y das Vorzeichen von x um, wenn x negativ ist.

Aus der Mathematik ist dies als Betragsfunktion bekannt.

Switch-Case-Anweisung

Die Switch-Case-Anweisung ist dann gut, um bspw. mehrere if-Anfragen des gleichen Typs in einem Abwasch abzuhandeln.

Haben wir z.B. einen Code, wie diesen hier

int x = // Ergebnis wird durch irgendwas übergeben

if (x == 1) {
  System.out.println("Der Wert von x ist 1!");
}

if (x == 2) {
  System.out.println("Der Wert von x ist 2!");
}

// usw...

kann man dies viel einfach mit einer Switch-Case lösen:
Weiterlesen

while-Schleife

Jede while-Schleife hat die Form

while(<Bedingung>) {
  <Schleifeninhalt>
}

Die muss wie schon bei der if-Abfrage vom Typ boolean sein. Sie muss also wahr (true) oder falsch (false) sein!
Weiterlesen

do-while-Schleife

Die do-while-Schleife ist der while-Schleife sehr ähnlich!

Sie hat die Form:

do {
  // Quelltext
} while (<Bedingung>);

Der einzige Unterschied zur while-Schleife ist der, dass die Bedingung immer nach einem Schleifendurchlauf geprüft wird (und nicht vor einen Durchlauf wie bei der while-Schleife).

So ist es auch möglich zu garantieren, dass auf jeden Fall die Schleife einmal durchgelaufen wird, unabhängig davon, ob die Bedingung wahr ist oder nicht!

Beispiel:

		boolean falsch = false;
		
		do {
			System.out.println("obwohl die Variable falsch false ist, laufe ich hier einmal durch!");
		} while (falsch);

mit der Ausgabe:

obwohl die Variable falsch false ist, laufe ich hier einmal durch!