Kontrollstrukturen
Bisher wurden unsere Programme Anweisung für Anweisung nacheinander abgearbeitet. Um den Programmfluss steuern zu können, gibt es Verzweigungen und Schleifen. Damit lassen sich Anweisungen in Abhängigkeit von bestimmten Bedingungen ausführen und wiederholen.
if … else …
Bei einer Verzweigung werden bestimmte Anweisungen nur dann ausgeführt, wenn eine bestimmte Bedingung erfüllt ist. Die allgemeine Form lautet:
if ( Bedingung ) {
Anweisungen;
}
Beispiel:
if ( dicke > 0 ) {
strokeWeight( dicke );
}
Das Beispiel setzt die Linienstärke auf den Wert in der Variablen „dicke“, aber nur wenn diese größer als 0 ist.
Wenn der Ausdruck in der Klammer true ergibt, werden die Anweisungen in den geschweiften Klammern ausgeführt.
Die geschweiften Klammern sind überall dort notwendig, wo Anweisungen zu einem Block gruppiert werden sollen. Ohne die Klammern wüsste das Processing nicht, welche Anweisungen es bedingt ausführen soll. Die Anweisungen zwischen den geschweiften Klammern sind hier eingerückt, was der Lesbarkeit dient. Das sollte man unbedingt machen, insbesondere bei verschachtelten Schleifen. Processing rückt Anweisungen in Verzweigungen und Schleifen automatisch ein, wenn man Strg-T (oder “Auto Format” aus dem Menü Tools wählt).
Optional kann man mit „else“ auch noch angeben, was passieren soll wenn die Bedingung nicht erfüllt ist:
if ( dicke > 0 ) {
strokeWeight( dicke );
} else {
strokeWeight( 1 );
}
Im „else-Teil“ können wieder „if“ auftauchen, so dass man auch komplexe Entscheidungen treffen kann:
if ( numberOfEnemies > 100 ) {
println( „Red“ );
} else if ( numberOfEnemies > 50 ) {
println( „Orange“ );
} else if ( numberOfEnemies > 10 ) {
println( „Yellow“);
} else {
printl( „white“ );
}
while – Schleife
Bei einer Schleife werden bestimmte Anweisungen so lange wiederholt, wie eine Bedingung erfüllt ist:
while ( Bedingung ) {
Anweisungen
}
Hier wird eine Variable zunächst auf 0 gesetzt (Initialisierung). In der Bedingung wird geprüft, ob die Variable kleiner als 100 ist. Wenn die Variable 100 oder höher ist, wird die Schleife nicht mehr ausgeführt und das Programm geht nach der Schleife weiter. Innerhalb der Schleife (zwischen den geschweiften Klammern) wird die Variable um 1 erhöht.
int counter = 0;
while( counter < 100 ) {
println( counter );
counter = counter + 1;
}
Bei Schleifen ist es immer wichtig, dass die Bedingung irgendwann „false“ ergibt, also nicht mehr erfüllt ist, sonst hängt das Programm in einer Endlosschleife. Würde die Variable „counter“ im obigen Beispiel nicht in jedem Durchlauf erhöht, würde die Schleife ewig weiterlaufen, weil counter niemals größer als 100 wird.
for – Schleife
Weil Schleifen häufig nach diesem Schema ablaufen:
- Initialisierung (einmalig)
- Prüfung der Bedingung (vor jedem Durchlauf)
- Verändern der Variablen (nach jedem Schleifendurchlauf)
gibt es eine komplexere Schleife, die all diese Schritte zusammenfasst, mit Semikolon ; getrennt:
for( Initialisierung; Bedingung; Veränderung ) {
Anweisungen;
}
Die obige Schleife sieht dann so aus:
for( int counter = 0; counter < 100; counter = counter + 1 ) {
println( counter);
}
Die Initialisierung wird einmalig ausgeführt. Die Bedingung wird vor jedem Durchlauf geprüft, falls sie true ergibt werden die Anweisungen im Schleifenrumpf ausgeführt, anschließend die Veränderung im 3. Teil.
Die folgende Schleife zeichnet Kreise im Abstand von 50 Pixeln nebeneinander:
int abstand = 50;
for( int x = 0; x < width; x = x + abstand ) {
ellipse( x, height/2, 30, 30 );
}
Schleifen können auch ineinander verschachtelt werden. Wenn wir beispielsweise das ganze Fenster mit Kreisen füllen wollen, geht das so:
int abstand = 50;
for( int x = 0; x < width; x = x + abstand ) {
for( int y = 0; y < height; y = y + abstand ) {
ellipse( x, y, 30, 30 );
}
}
Einige Abkürzungen:
statt
x = x + 50
können wir auch schreiben:
x += 50;
(das geht auch mit * – / usw.)
Wollen wir eine Variable um 1 erhöhen, kann man noch kürzer schreiben:
x++;
Boolsche Operationen
Noch etwas zu den Bedingungen:
Bedingungen sind in diesem Fall Ausdrücke, die einen Wert vom Typ boolean (= Wahrheitswert) ergeben, also die entweder true oder false zurückliefern. Das sind z.B. die mathematischen Vergleichsoperatoren:
< kleiner als > größer als == gleich (wichtig: doppeltes ==, weil einfaches = der Zuweisungsoperator ist !!) != nicht gleich
Der Ausdruck „100 > 10“ ergibt z.B. true, der Ausdruck „100 == 10“ ergibt false.
Man auch mit Wahrheitswerten rechnen. Die wichtigsten Operationen sind dabei:
& (und) | (oder) ! (nicht)
Hat man z.B. 2 Ausdrücke, die jeweils true oder false ergeben:
mouseX > 0 // Mausposition ist größer als 0 und mouseX < width // Mausposition ist kleiner als Fensterbreite
kann man diese mit und verknüpfen:
(mouseX > 0) & (mouseX < width)
Dieser Ausdruck ergibt genau dann true, wenn die Mausposition größer als 0 und kleiner als die Fensterbreite ist. Jeder der Teilausdrücke sollte in Klammern gesetzt werden. Will man z.B. überprüfen, ob die Mausposition innerhalb eines bestimmten Bereiches im Fenster ist, kann man das wie folgt machen:
int links = 20;
int oben = 20;
int rechts = 40;
int unten = 40;
if ( (mouseX > links) & (mouseX < rechts) & (mouseY > oben) & (mouseY < unten) ) {
rect( links, oben, rechts, unten );
}