Verschachtelte Verzweigungen mit if und else in Java

Worum geht´s?

In diesem Java Tutorial bauen wir auf den einfachen Verzweigungen vom letzten Tutorial auf, um verschachtelte if und else zu bauen. Wir werden uns ansehen, wie wir damit auch komplexe Baumstrukturen schaffen können. Und wie uns Papier und Stifte helfen können, den Prozess dabei zu vereinfachen.

Ein einfaches verschachteltes if und else

Nehmen wir als Grundlage wieder unser Beispiel von den einfachen if und else:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
        }
        else {
            System.out.println("a ist NICHT größer als 5");
        }
    }
}

Dieses Beispiel teilt sich durch das if und das else in zwei mögliche Wege, wie das Programm ablaufen kann.

Was aber, wenn wir weitere „Abzweigungen“ einführen wollen?

Dann müssen wir innerhalb unserer if-Blöcke oder/und unserer else-Blöcke weitere if einbauen:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
            int b = r.nextInt(20);
            if (b > 10) {
                System.out.println("Du hast Glück!");
            }
        }
        else {
            System.out.println("a ist NICHT größer als 5");
        }
    }
}

In diesem Fall würde, wenn (a > 5) ist, noch eine Variable b mit einer Zufallszahl von 0-19 erstellt. Und falls diese größer als 10 ist, noch „Du hast Glück!“ ausgegeben.

Der linke „Ast“ unseres Baumes hat also noch eine weitere Verzweigung bekommen:

Der linke Zweig unseres „Baumes“ hat keinen false-Teil, weil wir ja keinen else-Block hinzugefügt haben.

Würden wir das tun, erhalten wir folgenden „Baum“:

Der Java-Code dazu:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
            int b = r.nextInt(20);
            if (b > 10) {
                System.out.println("Du hast Glück!");
            }
            else {
                System.out.println("Du hast leider Pech!");
            }
        }
        else {
            System.out.println("a ist NICHT größer als 5");
        }
    }
}

Dasselbe können wir natürlich auch noch in unserem ursprünglichen else-Block machen, also auch dort ein weiteres if einbauen:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
            int b = r.nextInt(20);
            if (b > 10) {
                System.out.println("Du hast Glück!");
            }
            else {
                System.out.println("Du hast leider Pech!");
            }
        }
        else {
            System.out.println("a ist NICHT größer als 5");
            int b = r.nextInt(100);
            if (b == 50) {
                System.out.println("Du bist ein absoluter Glückspilz!");
            }
        }
    }
}

Als Baum würde das Ganze dann so aussehen:

So einen Baum kannst du im Prinzip unendlich weit „verästeln“.

Auf Dauer kannst du statt „true“ und „false“ auch nur noch „t“ und „f“ schreiben, oder die Bezeichnung auch ganz weglassen, weil ohnehin der eine Ast links und der andere rechts ist.

Falls du dich fragst, warum die Befehle innerhalb der if- und else-Blöcke eigentlich nicht vorkommen:

Das ist deswegen, weil man sonst sehr viel schreiben müsste. Wenn nur die Verzweigungen aufgezeichnet werden, bekommt man trotzdem ein recht gutes Bild davon, was in welchem Fall passieren wird.

Verschachtelungen abkürzen mit else if

Falls sich innerhalb eines if- oder eines else-Blocks nur eine einzige Anweisung (z.B. ein einziges System.out.println() oder eine einzige Rechnung) befindet, können die {}-Klammern auch weggelassen werden.

Aus diesem Grund ist es auch möglich, mit else if zu arbeiten. Was das ist, wird dir gleich sichtbar werden. Schauen wir uns mal folgende verschachtelte if else an:

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
        }
        else {
            if (a > 8) {
                System.out.println("Du bist ein absoluter Glückspilz!");
            }
        }
    }
}

In unserem else-Block ist dabei nur eine einzige Anweisung zu finden, nämlich ein if-Block.

Wenn das der Fall ist, können wie beschrieben die {}-Klammern weggelassen werden. Wenn wir das bei unserem else-Block machen, schaut das so aus:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
        }
        else 
            if (a > 8) {
                System.out.println("Du bist ein absoluter Glückspilz!");
            }
        
    }
}

Wenn wir nun das if im else-Block direkt hinter das else dran schreiben und die Leerzeile die entstanden ist löschen, bekommen wir ein else if:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("a ist größer als 5");
        }
        else if (a == 0) {
                System.out.println("Du bist ein absoluter Glückspilz!");
        }
    }
}

Die }-Klammer unseres „inneren“ if-Blocks, der jetzt direkt nach dem else startet, wird dabei auf die Höhe des else gebracht.

Hätte unser ursprünglicher „innerer“ if-Block auch noch einen else-Block, so kann dieser wiederum unten „drangehängt“ werden, und so weiter, um z.B. so etwas zu erreichen:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        // erstelle zahl zwischen 1 und 6
        int a = r.nextInt(10);

        if (a > 5) {
            System.out.println("Leider Pech gehabt");
        }
        else if (a == 0) {
            System.out.println("Du bist ein absoluter Glückspilz!");
        }
        else if (a == 1) {
            System.out.println("Schon noch ziemlich mächtig!");
        }
        else {
            System.out.println("Trostpreis. Immerhin!");
        }
    }
}

Hier wird ausgegeben:

• Wenn über 5: „Leider Pech gehabt“
• Wenn 0: „absoluter Glückspilz“
• Wenn 1: „ziemlich mächtig“
• Alle anderen: „Trostpreis“

So lassen sich z.B. Zahlen-Bereiche relativ gut abdecken.

if else Bäume zeichnen und nachprogrammieren

Was aber, wenn so ein verschachteltes if und else einfach zu kompliziert ist, um es noch im Kopf durchzudenken?

Dann kannst du dir mit Zettel und Stift einfach eine Baumstruktur aufzeichnen, ohne an korrekten Java-Code denken zu müssen.

Beginnend von oben kannst du nun einfach deinen Baum durchgehen, und die if und else entsprechend verschachteln.

Wo der Pfeil nach links zeigt, musst du das was folgt in den if-Block geben.

Zeigt der Pfeil nach rechts, musst das Folgende in den else-Block geben.

Ist das was kommt erneut eine Verzweigung, brauchst du erneut einen if-Block.

Mit ein wenig Übung können solche Bäume recht hilfreich sein.

Viel Freude damit 🙂

Diskussion zum Tutorial