Skip to main content

Java If und else Bedingungen – So verbesserst du die Kontrolle in deinem Programm

Und wenn sie nicht gestorben sind, dann …..
So oder so ähnlich enden viele Kindermärchen.

Oder wenn ich Millionär wäre, dann würde ich nicht mehr arbeiten.

Was haben die beiden Ausdrücke gemeinsam?

Ja richtig.
Sie stellen eine Bedingung voran.

Im ersten Beispiel wäre die Bedingung:
Wenn sie nicht gestorben sind.
Oder anders gesagt: Wenn sie noch leben.

Im zweiten Beispiel wäre die Bedingung:
Ich bin Millionär.

Und wenn diese Bedingungen eintreten, dann folgt eine Handlung oder eine zweite Aussage.

Du ahnst es bereits.

Wir beschäftigen uns wieder mit dem Datentyp boolean und der Aussagenlogik.

Du kannst nämlich auch sagen, wenn die Bedingung:
Ich bin Millionär den Wahrheitswert true liefert, dann gehe ich nicht mehr arbeiten.

Und so eine Bedingung kannst du in Java auch ausdrücken.

In diesem Beitrag möchte ich dir gern zwei Anwendungsformen von Java Bedingungen vorstellen.

  • Die bedingte Anweisung
  • Die bedingte Zuweisung

So nutzt du die bedingte Anweisung in der Java Programmierung

Bleiben wir beim Millionär.

Das gefällt mir. 🙂

Du hast die Bedingung: Millionär.
Und diese Bedingung kannst du in einem Vergleich ausdrücken.

Lege eine Variable vermoegen an und diese muss einen Wert von mindestens 1.000.000 haben.
vermoegen >=1_000_000

Und jetzt kannst du das ganze prüfen.

  • Der Prüfvorgang beginnt immer mit dem Java Keyword if.
  • Dann folgt in Klammern immer die Bedingung, welche überprüft werden soll. (Vermögen größer oder gleich 1.000.000).
  • Und dann kommt ein Codeblock. (zwei geschweifte Klammern)
    Dieser enthält die Anweisung, wenn die Bedingung wahr ist.

Und so sieht der Code dazu aus.


public class BedingungenProgramm{
public static void main (String [] args){
int vermoegen=1_000_000; //Variable vermoegen und Wertzuweisung
if (vermoegen>=1_000_000)//in Klammern steht die Bedingung
{//öffnende Klammer für den if Block
System.out.println("Hurra Millionär");//Anweisung wenn Bedingung eintritt
}//schließende Klammer if Block
}//schließende Klammer main Methode
}//schließende Klammer Klasse

Klicke auf Run und probiere es einmal aus.

Solange der Wert der Variable „vermoegen“ über oder gleich einer Million ist, springt das Programm in den Codeblock und führt diesen aus.

Ändere den Wert der Variablen „vermoegen“ einmal ab.
Setze einen Wert unter einer Million fest.


public class BedingungenProgramm{
public static void main (String [] args){
int vermoegen=1_000;
if (vermoegen>=1_000_000){
System.out.println("Hurra Millionär");
}
}
}

Klicke auf Run.
Was passiert?

Es passiert nichts.

Wieso?
Du hast dem Programm noch keine Anweisung gegeben, wenn die Bedingung nicht wahr ist.

Das ändern wir.

Setze unter dem Codeblock für die If-Anweisung, ds Java Keywort else.
Setze auch hier wieder einen Codeblock ein. (zwei geschweifte Klammern).

In die else Anweisung schreibst du, was passieren soll, wenn die Bedingung (vermoegen>=1.000.000) falsch ist.


public class BedingungenProgramm{
public static void main (String [] args){
int vermoegen=1_000;
if (vermoegen>=1_000_000)
{//öffnende Klammer if Block
System.out.println("Hurra Millionär");
}//schließende Klammer if Block
else
{//öffnende Klammer else Block
System.out.println("Mist kein Millionär");
}//schließende Klammer else Block
}//schließende Klammer main Methode
}//schließende Klammer der Klasse

Führe das Programm aus.

Spiele ein bisschen rum.
Weise der Variablen „vermoegen“ Werte unter 1.000.000 und über einer Million zu.

Du siehst, dass Programm prüft die Bedingung.
Es stellt fest ob die Bedingung true oder false liefert.
Falls die Bedingung true also wahr ist, springt es in den if-Bock.
Ansonsten springt es in den else Block.

Lass uns die if else Anweisungen erweitern

Ich steh auf Genauigkeit.

Ich möchte genauere Angaben zurückbekommen.

Und zwar möchte ich, dass:

  • Wenn der Wert über 1.000.000 ist – die Ausgabe erscheint „Hurra Millionär“
  • Ab einem Wert von 500.000 soll die Ausgabe erscheinen „Hälfte geschafft“
  • Ab einem Wert von 750.000 soll die Ausgabe erscheinen „drei Viertel geschafft“
  • Alles unter 500.000 soll die Ausgabe erscheinen „fleißig weiter arbeiten“

Du brauchst jetzt mehrere Überprüfungen.
Besser gesagt. Du musst deine If Anweisung schachteln.

Und das machst du, indem du unterhalb deines if Blockes mehrere else if Blöcke einfügst.

Und so sagst du es der Maschine.

  • Wenn der Wert unter 500.000 ist, dann spring in den If Block und führ diesen aus.
  • Wenn der Wert zwichen 500.000 und 750.000 ist, dann springe in den ersten else if Block (<750.000) und prüfe dort den Wert.
  • Und wenn du in diesem if else Block den Wert findest dann gib die Anweisung aus.
  • Ansonsten springe aus der gesamten if-Anweisung und springe in den else Block und führe diesen aus.

Und so sieht der code aus:


public class BedingungenProgramm{
public static void main (String [] args){
int vermoegen=1_000;
if (vermoegen< 500_000){

System.out.println("feißig weiter arbeiten");
}

else if (vermoegen< 750_000){

System.out.println("Hälfte geschafft");
}

else if (vermoegen< 1_000_000){

System.out.println("drei Viertel geschafft");
}

else{

System.out.println("Hurra Millionär");
}
}
}


So kannst du einer Variablen einen bedingten Wert zuweisen.

Ich will es noch genauer.

Und zwar möchte ich eine Variable namens Arbeitsstunden einführen.

Und in dieser Variablen sollen die Arbeitsstunden abgespeichert werden, welche ich noch zu leisten habe.

  • Bei einem Vermögen ab 1.000.000 soll der Wert 0 sein.
  • Bei unter 500.000 soll der Wert 1.000 sein.
  • Bei einem Vermögenswert zwischen 500.000 und 750.000 soll der Wert 500 sein.
  • Und bei einem Vermögen zwischen 750.000 und 1.000.000 sollen die Arbeitsstunden 250 sein.

Zur Überprüfung gebe ich dann den Wert der Variablen in der main Methode aus.


public class BedingungenProgramm{
public static void main (String [] args){
int vermoegen=1_000;
int arbeitsStunden=0;
if (vermoegen< 500_000){

System.out.println("feißig weiter arbeiten");
arbeitsStunden=500;
}
else if (vermoegen< 750_000){

System.out.println("Hälfte geschafft");
arbeitsStunden=250;
}
else if (vermoegen< 1_000_000){

System.out.println("drei Viertel geschafft");
}
else {

System.out.println("Hurra Millionär");
arbeitsStunden=0;
}
System.out.println(arbeitsStunden);
}
}


Für die if else Anweisung benötigst du in Java nicht unbedingt den Codeblock

Doch Achtung….

So etwas kann sehr schnell schiefgehen.

Ein einfaches Beispiel.
Eine Zahl soll überprüft werden. Wenn diese Zahl Null ist, dann erfolgt die If Anweisung ("Zahl ist Null").
Wenn die Zahl ungleich Null ist, erfolgt die else Anweisung. ("Zahl ungleich Null")

If und else Blöcke ohne Klammern

public class BedingungenProgramm{
public static void main (String [] args){
int einfacheZahl=1_000;
if (einfacheZahl==0)
System.out.println("Zahl ist Null");
else
System.out.println("Zahl ungleich Null");
}
}

Du siehst. Ich habe keine Codeblöcke (Klammern) verwendet.
Dennoch macht das Programm, was es machen soll.

Jetzt füge ich aber mal eine zweite Anweisung in den else Block ein.

Else Block mit zweiter Anweisung

public class BedingungenProgramm{
public static void main (String [] args){
int einfacheZahl=0;
if (einfacheZahl==0)
System.out.println("Zahl ist Null");
else
System.out.println("Zahl ungleich Null");
System.out.println("Bei der Zahl Null soll dieser Text nicht erscheinen");
}
}

Probiere doch einmal aus, was passiert.

Oh Problem.

Und zwar führt das Programm bei einem Wert von Null den If Block aus.
Aber das Programm springt dann in die zweite Anweisung des else Blocks.

So ein Mist.

Was ist los?
Du kannst auf die geschweiften Klammern verzichten, wenn bei if oder else nur jeweils eine Anweisung erfolgt.

Sobald mehr Anweisungen im else Block folgen, betrachtet Java dies nicht mehr als else Block.
In unserem Fall ist der Compiler schon wieder in der main Methode.

Deshalb empfehle ich dir immer Klammern zu setzen.

Zusammenfassung:

  • Um Bedingungen auszudrücken oder Werte abzufangen nutzt du in Java if und else Anweisungen.
  • Diese if Anweisungen prüfen die Bedingung und liefern dir einen logischen Ausruck wahr oder falsch zurück.
  • Falls die Bedingung war ist, springt dein Java Programm in den entsprechenden Block und führt die enthaltenen Anweisungen aus.
  • Wenn die Bedingung aber falsch ist, springt das Java Programm in den entsprechenden else Block und führt diesen aus.