GAME of CODES: Kontrollstruktur gefragt

Algorithmus und Kontrollstruktur

Kontrollstruktur: kümmern wir uns zunächst darum, was ein Algorithmus mit Teekochen zu tun hat:

Fülle 1-Liter-Wassertopf mit Wasser;;
Stelle Wassertopf auf Heizplatte;
Schalte Heizplatte ein auf Stufe 6;
Erhitze Wasser bis Wassertemperatur = 100 Grad Celsius;
Schalte Heizplatte aus;
Lasse Wasser auf 80 Grad Celsius abkühlen;
Hänge Teebeutel in den Wassertopf (Typ: schwarzer Tee);
nach 5 Minuten entferne den Teebeutel;

Kontrollstruktur erkennbar? Was Sie hier sehen, ist erkennbar die Handlungsanweisung, um einen Liter schwarzen Tee zu kochen: sequenziell verschiedene Anweisungen und einigermaßen erkennbar (?) zwei Wiederholungen. Mit anderen Worten, uns liegt ein Algorithmus vor, der das Problem „Tee kochen“ löst.
Natürliche Sprache kennt sehr viele „Befehle“:  fülle, stelle, schalte, erhitze, lasse-abkühlen, hänge, entferne…weil die natürliche Welt komplexer ist, so sind sehr viele Anweisungen (oder auch Befehle) denkbar.

Algorithmische Sprachen erfordern weniger Befehle für die Handlungsanweisungen eines Computers. Hier kommen die „Communications of the ACM“ ins Spiel!  Die beiden Wissenschaftler  Böhm und Jacopini  konnten im August 1967 in der Veröffentlichung in „Communications of the ACM“ (Volume 10, Issue 8, ISSN: 0001-0782) unter dem Titel „Böhm and Jacopini’s reduction of flow charts“ nachweisen, dass für die Steuerung des Kontrollflußes mit Hilfe einer strukturierten Programmiersprache drei Kontrollstrukturen ausreichend sind:

Böhm & Jacopini: Kontrollstrukturen
Böhm & Jacopini: Kontrollstrukturen

Böhm & Jacopini:

  • die Sequenz (Anweisungen nacheinander)
  • die Fallunterscheidung (auf der Grundlage boolescher Werte)
  • die Wiederholung (Anweisungen mit Hilfe von Schleifen und Methoden) und

 

 

 

Kontrollstrukturen in Java: die Sequenz

Anweisungen werden in Java durch den Strichpunkt voneinander getrennt. Na ja – streng genommen stimmt das nicht, den in Java ist der Strichpunkt ein Terminator – es werden also Anweisungen beendet. Weil danach, in der Regel, eine neue Anweisung kommt, können wir ein Nacheinander von Anweisungen erkennen und die Sequenz sehen. Als Sequenz angeordnet werden Einzelbefehle – oft Verknüpfungen von Daten mit Hilfe von Operatoren (z.B. arithmetische und logische Operatoren). Auch das nacheinander aufrufen von Methoden und Funktionen bedeutet eine Sequentialisierung von Anweisungen.

Im folgenden sehen wir eine Sequenz aus 5 Einzelschritten: drei Datendeklarationen vom Typ int, zwei davon mit Initialisierung und eine ohne explizite Initalisierung. Vierte Sequenzschritt ist die Differenzbildung (zuerst, und dann) die Zuweisung des Ergebnisses an die Variable aktuelles_gewicht. Der 5 und letzte Sequensschritt ist dann der Aufruf der Methode println(). Die Kommentare zählen wir nicht als Sequenzschritte, weil sie für den Algorithmus (und das Java-Programm) keine Rolle spielen:

int gewicht = 50;           // Deklaration
int gewichtsreduktion = 2;  // Deklaration 
int aktuelles_gewicht;      // Deklaration
// Zuweisung einer Differenz
aktuelles_gewicht = gewicht - gewichtsreduktion; 
// Ausgabeanweisung mit Hilfe Methode println()
System.out.println("Das aktuelle Gewicht beträgt: " 
                   + aktuelles_gewicht);

Kontrollstrukturen in Java: die Fallunterscheidung

Eine Fallunterscheidung kann sich über mehrere Zeilen erstrecken. Eine Fallunterscheidung in einem Programm bedeutet, dass häufig schon mehrere Zeilen zu lesen sind, um die gesamte Fallunterscheidung zu erkennen. Eine einfache Fallunterscheidung sieht folgendermassen aus:

if (aktuelles_gewicht < 55)  // logischer Vergleich,    
   {
   System.out.println("Supermodel?!");
   }
else if (aktuelles_gewicht < 65 ) 
     {
     System.out.println("Curvy Model?!")
     }
     else 
     {
     System.out.println("Schönheit regiert nur kurz - sagt Sokrates");
     }

Wir haben es hier mit einer Fallunterscheidung zu tun, innerhalb derer (im ersten else-Zweig) nochmals eine Fallunterscheidung vorkommt. Wenn die Prüfung, ob aktuelles_gewicht < 55 zutrifft, dann wird alles nach dem ersten else schon nicht mehr ausgeführt und auf dem Bildschirm erscheint „Supermodel?!“. (Natürlich werden Sie jetzt feststellen, dass die Prüfung zu schwach ist: wir müssten auch Lebensalter, Größe und Geschlecht berücksichtigen! Der 2-Meter-Mann im Alter von 30 wäre kein Supermodel sondern krank! Daran ist deutlich erkennbar, dass schon die Fallunterscheidung komplex sein kann). Hier wird im else-Zweig nochmals geprüft, ob aktuelles_gewicht < 65 ist. Stimmt dies, so wird auf dem Bildschirm „Curvy Model?!“ ausgegeben. Stellt sich die Prüfung als falsch heraus, so wir auf dem Bildschirm Sokrates zitiert.

youtubehttp://bit.ly/2f6FlGx (Illik, Wintersemester 16/17, JAVA1_VORUEB_4_1_if_ILLIK),

youtube http://bit.ly/2fu6hnX (Illik, Wintersemester 16/17, JAVA1_VORUEB_4_3_if_else_ILLIK).

Kontrollstrukturen in Java: die while-Schleife

Von der Wiederholung gibt es mehrere Formen. Die while-Schleife sieht im Grund relativ einfach aus:

int i = 0; // 1. Deklaration u. Initialisierung
           // unseres Schleifenkriteriums
while (i<11) //2. Prüfung
      { // wenn Prüfung zutrifft: Schleifenrumpf ausführen
      System.out.println("i hat gerade den Wert " + i);
      i++; // 3. die Schleifenvariable ändern
      } // Ende Schleifenrumpf
System.out.println("Die while-Schleife wurde verlassen!");

Im Grunde spielen 3 Dinge ein Rolle bei Wiederholungen: nach dem Schlüsserwort while wird geprüft, ob ein Kriterium erfüllt ist. Davor (1.) muss eine Variable deklariert sein (und hier mit 0) initialisiert sein. NUR wenn die Prüfung gut geht, sich als richtig erweist, nur dann wird der Schleifenrumpf ausgeführt. Das sind in unserem Fall oben alle Zeilen zwichen den geschweiften Klammern {}. Hier wir also die Meldung auf der Konsole ausgegeben, welchen Wert aktuell die int-Variable i hat. Nach der Ausgabe wird die Variable i um 1 hochgezählt. Also, die Anweisung i++ wirkt identisch mit der etwas längeren Anweisung i = i + 1; oder alternativ auch i += 1; (Typisch fürs Programmieren: „viele Wege führen nach Rom“ könnte man sagen und tatsächlich haben wir oft (nicht immer) verschiedene Möglichkeiten der Notation.)
Nach der Ausführung des Schleifenrumpfes, geht es wieder mit 2.Prüfung weiter, so wie oben beschrieben. Das geht solange, solange sich die Prüfung als richtig erweist. Sobald die Prüfung des Schleifenkriteriums sich als falsch erweist, wird der Schleifenrumpf nicht mehr ausgeführt und das Programm mach mit dem weiter, was nach dem Schleifenrumpf notiert ist: in unserem Fall hier ist es die Ausgaben „Die while-Schleife wurde verlassen!“.

youtube http://bit.ly/2fssGTo (Illik, Wintersemester 16/17, JAVA1_VORUEB_4_4_while_ILLIK).

Kontrollstrukturen in Java: die for-Schleife

Von der Wiederholung gibt es mehrere Formen, haben wir oben erfahren. Die for-Schleife unten implementiert den gleichen Sachverhalt (wir können auch sagen: den gleichen Algorithmus) wie die while-Schleife oben – sie ist aber übersichtlicher:

for (int i=0; i<11; i++)
    {
    System.out.println("i hat gerade den Wert " + i);
    }
System.out.println("Die while-Schleife wurde verlassen!");

Was in der while-Schleife über mehrere Zeilen verteilt ist (siehe die in der while-Schleife mit 1., 2., 3. gekennzeichneten stellen), all das ist in der for-Schleife unmittelbar nach dem Schlüsselwort for in den runden Klammern notiert, durch einen Strichpunkt getrennt!
Der 1. Ausdruck int i=0; deklariert das Schleifenkriterium, nach dem Strichpunkt deklariert der
2. Ausdruck i<11; die Prüfung und der
3. Ausdruck i++; ändert die Schleifenvariable
Machen Sie sich bewußt, dass bei der while-Schleife die Ausdrücke 1.,2. und 3. über verschiedene Zeilen verteilt sind und zusammengesucht werden müssen. Die for-Schleife macht dies besser: sie entspricht dem Prinzip der Lokalität und wir deswegen von Profis bevorzugt.

youtube  http://bit.ly/2faU9pc (Illik, Wintersemester 16/17, JAVA1_VORUEB_4_5_for_ILLIK).

Kontrollstrukturen in Java: die switch-case-Anweisung (mehrfache Fallunterscheidung)

Die mehrfache Fallunterscheidung hat natürlich was mit der if-else-Anweisung zu tun und ist immer dort interessant, wenn im Algorithmus mehr Alternativen vorgesehen sind.

Am Besten Sie schauen sich die Vorübung 4.6: Fallunterscheidung mit switch-case-Konstruktion (siehe Felix und YouTube) an und „knacken“ die Funktionsweise der switch-case-Anweisung.

youtube   http://bit.ly/2famk7l (Illik, Wintersemester 16/17, JAVA1_VORUEB_4_6_switch-case_ILLIK).

Nachdem Sie die „JAVA1_VORUEB_4_6…“ entzaubert haben, hier zum Schluss noch eine kleine Lese-Übung. Programme zu analysieren gehört ja gewissermassen zum Tagesgeschäft:

public class SwitchKonstruktion_b {

	public static void main(String[] args) {
		int antwort;
		System.out.print("Bitte ganze Zahl eingeben, ");
		antwort = StdInput.readInt("[zwischen 0 u. 10]: ");
		System.out.printf("Deine Eingabe:%03d \n",antwort);
		switch(antwort)
		{
		case 0:
		case 2:
		case 4:
		case 6:
		case 8:
		case 10:
		{
			System.out.printf("%03d", antwort);
			System.out.println(" ist GERADE Zahl!");
			break;
		}
		case 1:
		case 3:
		case 5:
		case 7:
		case 9:
		{
			System.out.printf("%03d ", antwort);
			System.out.println("ist UNGERADE Zahl!");
			break;
		}
		default:
			System.out.println("Zahl nicht im Scope!");

		} // end of switch-case
		System.out.println("Ende des Programms.");
	} // end of main()
} // end of class

Abgesehen von der switch-case-Kontrollstruktur gibt vielleicht auch die Ausgabe System.out.printf() Rätsel auf. Hier ein Ansatz zur Enträtselung mit Hilfe der API-Beschreibung:

  1. System“ ist eine Class – suchen Sie diese in der API-Beschreibung.
  2. out“ ist ein Field (zu Deutsch: ein Feld in der Klasse)- finden Sie in der API-Beschreibung unter Class System in der „Field Summary“. Dort erkennen Sie, dass das Field „out“ vom Typ PrintStream ist.
  3. Wenn Sie in der „Field Summary“ jetzt auf „PrintStream“ klicken, kommen Sie in die Beschreibung der Class PrintStream. Hier scrollen Sie zur „Method Summary“ und finden alle auf PrintStream-Objekte anwendbaren Methoden, unter anderem eben auch die Methode printf().

Versuchen Sie über diese Einstiegshilfe etwas über die Parameter der PrintStream-Methode printf() in Erfahrung zu bringen.

Fragen und weiter Details besprechen wir in der Vorlesung.

 

2 Gedanken zu „GAME of CODES: Kontrollstruktur gefragt“

Schreibe einen Kommentar