Kontrollstrukturen in Java – Verzweigungen und Schleifen erklärt

Um unserem Programm nun all seine Funktionen zu geben, durch die es funktioniert, benötigen wir Kontrollstrukturen. In diesem Beitrag zeige ich dir welche Kontrollstrukturen es gibt, wie man sie darstellt und implementiert.

Was sind Kontrollstrukturen?

Klären wir zuerst mal die Frage: „Was sind Kontrollstrukturen?“. Dazu werfen wir ein Blick auf die Definition.

Kontrollstrukturen (Steuerkonstrukte) sind Anweisungen in imperativen Programmiersprachen. Sie werden verwendet, um den Ablauf eines Computerprogramms zu steuern.[…]

Wikipedia, Beitrag: „Kontrollstruktur“; Stand: 27.Februar 2020

Also wie du jetzt sehen kannst, besteht jedes Programm aus Kontrollstrukturen. Durch die richtige Aneinandereihung der verschiedenen Kontrollstrukturen, kann man sein Programm verschiedene Aufgaben erledigen lassen. Die Folge von Kontrollstrukturen nennt man Algorithmus. Wirf doch gleich mal einen Blick in diesen Beitrag: Algorithmus- Eigenschaften und Laufzeit. Dort erkläre ich dir ganz ausführlich was ein Algorithmus ist, welche Eigenschaften er hat und wie du die Laufzeit bestimmen kannst.

Wenn man versucht einen Algorithmus zu entwerfen, ist eine der ersten Sachen die man macht die einzelnen Schritte kurz darzustellen. Eine Möglichkeit dazu ist das erstellen eines Nassi-Schneiderman-Diagramms, auch Struktogramm genannt. Hier hat jede Kontrollstruktur eine Darstellung mit einfachen geometrischen Formen und entsprechende kurze Bezeichnungen der Befehle in Ihnen. So kann man schnell erkennen welche Kontrollstrukturen enthalten sind. Die einzelnen Elemente um ein solches Diagramm erstellen zu können zeige ich dir im Nächsten Abschnitt.

Welche Kontrollstrukturen gibt es?

Wir haben insgesamt drei verschiedene Kontrollstrukturen: die Sequenz, die Verzweigung und die Schleife. Was die einzelnen Kontrollstrukturen sind erkläre ich dir jetzt. Fangen wir mit der einfachsten an, der Sequenz.

Die Sequenz

Eine Sequenz ist eine einfache Abfolge von Befehlen. Sie führt Befehle genau so wie du sie geschrieben hast, Zeile für Zeile aus. Simpel oder?

Sequenz - Kontrollstruktureb
Nassi-Schneiderman Element der Sequenz

In einem Struktogramm ist das die Darstellung der Sequenz. Jedes Kästchen ist hier ein Befehl. Den entsprechenden Befehl schreibt man dann in das Kästchen.

Die Verzweigung

Jetzt wird es interessant. Eine Verzweigung kennzeichnet sich dadurch, dass du dort immer eine Bedingung hast und je nachdem ob die Bedingung true oder false ist wird ein anderer Teil deines Programms ausgeführt(Wenn-dann).

Die einfachste Form der Verzweigung ist ein einfacher if-Block.

Die einfache if (Wenn-dann)

Bei einer einfachen if gibt es immer genau eine Bedingung und genau einen Block der ausgeführt wird wenn die Bedingung zutrifft. Du kannst den Programmcode also auch so lesen: „Wenn … erfüllt ist, dann …….. „. Genau durch diesen Satz ist die einfache if definiert.

Im Quellcode sieht das dann so aus:

if(Bedingung) {
 //was auch immer dein Programm tun soll
}


Struktogram:

Verzweigung 1

Wenn es eine einfache Verzweigung gibt, gibt es natürlich auch eine mehrfache Verzweigung.

Die mehrfach Verzweigung

Um eine mehrfach Verzweigung zu erstellen gibt es verschiedene Möglichkeit. Die Möglichkeit die am häufigsten genutzt wird ist die if-else.

If-else

Die if-else erweitert die einfache if von eben, um einen weiteren Block. Sie sagt also: „Wenn ….. erfüllt ist, dann ……., SONST …….“. Sie gibt also deinem Programm nun einen weiteren Block und sagt ihm was es tun kann wenn die Bedingung nicht erfüllt ist.

Verzweigung 2

Das ganze sieht im Quelltext dann so aus:

if(Bedingung){
 // mach das
} else {
 // sonst mach das
}

Das ganze kannst du auch noch weiter erweitern.

Wenn du beispielsweise die else nicht einfach ausführen möchtest, dann kannst du dort einfach noch einmal ein if dran hängen. Dann werden der Reihe nach die verschiedenen Möglichkeiten geprüft.

Ein mögliches Konstrukt könnte also zum Beispiel so aussehen:


if(Bedingung) {
      // tu dies
} else if(nächste Bedingung){
      // mach das
      if (Bedingung3) {
              // tu dies auch
       }
}

Wie du sehen kannst, kannst du auch mehrere Verzweigungen ineinander stapeln (kaskadieren). Hierbei musst du aber vorsichtig sein, dass du die Klammern richtig setzt. Sonst bekommst du ganz schnell ein „Dangling-else-Problem„. So nennt man das Problem, dass es unklar wird zu welchem if nun welches else gehört.

Abgesehen davon, solltest du daran denken, dass die inneren if-Blöcke nur ausgeführt werden, wenn die erste Bedingung auch erfüllt ist.

Die if-Anweisungen solltest du nun gut genug kennen, also kommen wir zu ihren großen Bruder: der switch-Anweisung.

switch-case

Ich hab die switch-case gerade den großen Bruder der if genannt. Damit wollte ich darauf hinaus, dass du bei der switch-case nicht nur 2 mögliche Blöcke hast die ausgeführt werden können.

Die switch-case sieht wie folgt aus:

switch(Operation){
case 1: 
      // Aktion für den block
      break;
case 3: 
     //Aktion für den Block
     break;
case 4:
     //Aktion für den Block
     break;
}

Sie ist ebenfalls eine Mehrfach-Verzweigung, so wie die if-else. Hier musst du nur aufpassen welche Werte du in Welcher Sprache wirklich vergleichen kannst. So kannst du beispeilsweise in Java erst seit Version 1.7 ebenfalls Strings vergleichen. Ansonsten gehen nur primitive Int Werte.

Switch-case Verzweigung Kontrollstrukturen

Du packst oben bei der switch-case eine Variable oder Operationen rein, die im Programmablauf durch die Definition einer Variablen gelöst wird.

Also zum Beispiel x +5. Je nachdem wie das x dann im Programmablauf definiert wird, erhältst du unterschiedliche Werte.

Nun musst du abschätzen können welche möglichen Werte dein Ausdruck annehmen kann. Das sind dann nämlich deine cases.

Also zum Beispiel:

switch(x+5){ //x kann die Werte 3, 5 und 7 annehmen, dann hast du die cases: 
case 8: // für x = 3
 // Aktion für den Block
break;
case 10: // für x = 5
     //Aktion für den Block
break;
case 12: // für x = 7
  //Aktion für den Block
     break;
}

Das break, das du nach jedem Block siehst, ist notwendig das der Block auch beendet wird. Wenn du die breaks nicht machst werden einfach alle Blöcke nacheinander ausgeführt. Wobei es auch Situationen geben kann wo genau das gewollt ist.

Und damit kommen wir zu der letzten Kontrollstruktur: den Schleifen.

Die Schleife/ Loop

Die letzte Kontrollstruktur die wir nun zu betrachten haben, sind die Schleifen (engl. Loops). Mit Schleifen können wir einen bestimmten Programmteil immer und immer wieder ausführen.

Es gibt 3 verschiedene Arten von Schleifen, wobei eine eine Abwandlung ist.

Die while-Schleife

Bei der while (deutsch: solange) Schleife, wiederholen wir den Inhalt der Schleife so lange, bis die Bedingung nicht mehr gültig ist und den Wert false annimmt. Du solltest hier genau aufpassen, kann deine Bedingung nicht erfüllt werden erschaffst du eine endless-loop die schnell dein Programm zum Absturz bringt.

Sie hat folgende Form:

while(Bedingung){
 // mach irgendwas
}

Hier wird also überprüft ob die Bedingung den Rückgabewert true liefert. Solange sie das tut wird der Teil des Programms immer wieder ausgeführt.

While-Loop/schleife Kontrollstrukturen

Eine Abwandlung der while Schleife ist die do-while-Schleife.

do-while Schleife

Die do-while Schleife macht genau das selbe wie die while. Der einzigen Unterschiede bestehen darin, dass die Syntax(Schreibweise) anders ist und das sie die Bedingung am Ende überprüft und nicht am Anfang. Sie führt also den auszuführenden Programmteil erstmal aus und überprüft dann ob die Bedingung noch gültig ist und nochmal wiederholt werden muss.

Syntax:

do{
//was auch immer dein Programm tun soll
} while (Bedingung)

Die letzte Schleifenart ist die Zählschleife.

Die for-Schleife (Zählschleife)

Bei der for-Schleife wird der zu wiederholende Programmteil genau so oft wiederholt, wie man es vorher definiert hat. Die Schleife hat einen Anfangswert, einen Endwert und eine Schrittweite um die der Anfangswert immer erhöht wird. Die Schleife läuft dann solange bis der Endwert erreicht ist, dann bricht die Schleife ab.

Beispiel:

for(int i = 0; i < 5; i++){
System.out.println("Hallo");
}

Das Programm gibt bei dem Beispiel genau 5 mal „Hallo“ auf der Konsole aus.

Das ++ heißt soviel wie: erweitere jedesmal um 1. Das könnte man aber auch so ausdrücken: i += 1 oder I = i+1. Alle 3 Varianten tuen genau das selbe. Sie erhöhen den Wert i um 1. Genau das selbe gilt natürlich auch für Minus.

Struktogram:

For-Schleife/loop Kontrollstrukturen

Lass doch einen Kommentar da und erzähl mir wie dir der Beitrag gefallen hat oder ob dir hier noch etwas fehlt. Liken und Teilen sind natürlich auch immer gern gesehen. Bis zum nächsten mal 🙂

Einen Kommentar hinzufügen

Deine E-Mail-Adresse wird nicht veröffentlicht.