2. Variablen und Schleifen

Aufgabe: Ein Gitter zeichnen.

Wenn man z.B. fünf horizontale Linien mit dem Abstand von 40 Punkten zeichnen möchte, dann werden die folgenden Zeilen das gewünschte Ergebnis liefern:
```
g.drawLine(0,   0, 400,   0);
g.drawLine(0,  40, 400,  40);
g.drawLine(0,  80, 400,  80);
g.drawLine(0, 120, 400, 120);
g.drawLine(0, 160, 400, 160);
```
Wenn man aber 50, 100 oder tausende von Punkten und Linien zeichnen möchte, werden wir mit diesem Zugang nicht sehr weit kommen. Um solche iterativen Probleme auf dem Computer effizient zu lösen, brauchen wir zwei wichtige Konzepte: Variablen und Schleifen.
Das Konzept der Variable ist eigentlich schon aus der Mathematik und Physik bekannt: y = 5 bedeutet, dass jedes Mal, wenn in einer Gleichung y vorkommt, dieses y den Wert 5 hat.
Wenn wir y = 7 setzen, dann hat y den Wert 7. Diese einfache Logik (und auch die Schreibweise!) ist aus der Mathematik direkt in die (meisten) Programmiersprachen übernommen. Jede dieser Sprachen hat aber auch weitere Feinheiten, die man beachten muss. Bei Java (genauso wie bei C) muss man zwei weitere Punkte beachten: eine Variable muss deklariert werden und die Zuweisung muss mit einen Semikolon (;) enden:
```
int y;
y = 5;
```
Sinn der Deklaration ist, dass wir dem Computer im Voraus sagen müssen, wieviel Speicherplatz er für diese Variable reservieren soll. Wenn wir nur mit den ganzen Zahlen arbeiten, dann deklarieren wir die Variablen als int (ganze Zahl heißt auf Englisch 'integer'). Ohne jetzt in die Details der internen Darstellung der Zahlen im Computer zu gehen, ist es klar, dass die Zahlen, die weitere Dezimalstellen beinhalten, auch mehr Speicherplatz benötigen - der Variablentyp float kann bis etwa sieben Dezimalstellen darstellen - und der Typ double doppel so viel:
```
float pi;
double dpi;
pi = 3.1415926;
dpi = 3.141592653589793;
```
Dass alle Befehle in Java mit einem Semikolon (;) enden müssen, haben Sie bestimmt schon selbst gemerkt. Damit ist es erlaubt, mehrere Befehle in eine Zeile zu packen (die Sprachen, welche nur einen Befehl pro Zeile erlauben - z.B. FORTRAN - brauchen diesen Strichpunkt nicht).

So, jetzt können wir unsere fünf Linien schon mit etwas besserem (aber noch nicht kürzerem) Code zeichnen:
```
int y;
y = 0;
g.drawLine(0, y, 400, y);
y += 40; g.drawLine(0, y, 400, y);
y += 40; g.drawLine(0, y, 400, y);
y += 40; g.drawLine(0, y, 400, y);
y += 40; g.drawLine(0, y, 400, y);
```
Der Befehl y += 40; addiert 40 zum momentanen Wert der Variable y, d.h. beim ersten drawLine ist y = 0, beim zweiten y = 40, beim dritten y = 80, etc. Statt y += 40; könnte man auch y = y + 40; schreiben.
Es fällt sofort auf, dass die Programmzeilen jetzt schon identisch sind und es ist angebracht, für diese Wiederholung eine verkürzte Schreibweise einzuführen:
```
int y;
for (y = 0; y < 200; y += 40)
{
  g.drawLine(0, y, 400, y);
}
```
Diese Konstruktion heißt for-Schleife und hat folgenden Effekt:
1. Zuerst wird y = 0 ausgeführt - WICHTIG: das passiert nur einmal, am Anfang!
  for(y = 0; y < 200; y += 40) {
  g.drawLine(0, y, 400, y);
  }
2. Dann wird die Bedingung y <200 überprüft.
  for(y = 0; y < 200; y += 40) {
  g.drawLine(0, y, 400, y);
  }
  
  Und weil y noch 0 ist, d.h. kleiner als 200, geht die Schleife weiter!
3. Als nächstes wird der Wert von y geändert und die Befehle in geschweiften Klammern werden ausgefuehrt:
  
  for(y = 0; y < 200; y += 40) {
  g.drawLine(0, y, 400, y);
  }
4. Schliesslich fängt die Schleife wieder von vorne an (deswegen Schleife!) - aber natuerlich ohne y wieder auf 0 zu setzen - d.h. es geht mit dem Punkt b) weiter.
  Diesmal ist y schon 80, aber noch immer kleiner als 200, c) wird wieder ausgeführt, und so geht es, bis die Bedingung y < 200 nicht mehr erfüllt ist. Dann wird die Schleife verlassen und der nächste Befehl hinter } ausgeführt:
  
  for(y = 0; y < 200; y += 40) {
  g.drawLine(0, y, 400, y);
  }
  ... und hier geht es weiter!
  
  Die eigentliche 'Kunst der Schleifen' ist, die richtige Abschlussbedingung zu wählen - denken Sie immer vorsichtig nach, wenn Sie diese Bedingung formulieren (z.B. wenn Sie noch eine weitere Linie bei y = 200 zeichnen wollen, können Sie auch y <= 200 benutzen;
  '<=' bedeutet 'kleiner gleich').
Jetzt sind Sie in der Lage, die Aufgabe zu lösen: Um ein Gitter zu zeichnen, verwenden Sie zwei Schleifen - für horizontale und vertikale Linien! (Abstände und Farben können Sie natürlich beliebig wählen.)

Hier geht es weiter ...