Am besten verdeutlicht man sich das mit einem Bild:

Hierbei werden die Werte 5, 2, 3, 4 an die Stellen von 0 bis 3 gespeichert. Bei späteren Berechnungen sollte man daran denken, dass ein Array mit dem Index 0 beginnt.

Überführen wir nun unser Bild in Java-Code, um die Verwendung von Arrays zu verdeutlichen:

int[] zahlArray = new int[4];
 
zahlArray[0] = 5;
zahlArray[1] = 2;
zahlArray[2] = 3;
zahlArray[3] = 4;

Mit den eckigen Klammern nach dem Typ sagen wir, dass wir ein Array erzeugen möchten. Die eckigen Klammern hinter die Bezeichnung des Arrays zu setzen ist auch möglich. Mit dem Schlüsselwort “new” erzeugen wir ein neues Array-Objekt, das Integer-Werte enthält und 4 Felder groß ist. Dabei können in einem Array nur Werte gespeichert werden, die auch zu dem angegebenen Typ passen. Würden wir nun versuchen einen String in unser Array zu speichern, bekämen wir eine Fehlermeldung.
Java bietet uns noch eine andere Möglichkeit Arrays zu erstellen:

int zahlArray[] = {5, 2, 3, 4};

Damit haben wir den obigen Code auf eine Zeile reduziert. Beides kann jedoch nicht kombiniert werden, sodass etwas wie dies nicht möglich ist und uns unweigerlich einen Compilerfehler bringt:

int[] zahlArray = new int[4];
zahlArray = {5, 2, 3, 4};

Dies können wir jedoch mit einem kleinen Trick umgehen:

int[] zahlArray = new int[4];
int[] zahlen = {5, 2, 3, 4};
 
zahlArray = zahlen;

Sowohl ist dies auch möglich:

int[] zahlArray = new int[]{5, 2, 3, 4};

Das größte Speichern von Arrays bringt uns nichts, wenn wir nicht auch auf die Werte darin zugreifen können. Dazu schreiben wir einfach hinter den Namen des Arrays in eckige Klammern den Indexwert, in denen unser gewünschter Wert gespeichert worden ist.

int[] zahlArray = {5, 2, 3, 4};
 
System.out.println(zahlArray[0]);

Mit zahlArray[0] greifen wir auf den Wert im Array zu, der unter dem Index 0 abgelegt worden ist. Da die Indizes bei Arrays mit 0 beginnen, erhalten wir als Ausgabe unsere 5.
Einige werden sich auch schon sicher Gedanken dazu machen wie man ein ganzes Array durchlaufen könnte, um auf alle Werte zugreifen zu können. Mit Array.length können wir bequem auf die Länge unseres Arrays zugreifen und somit mit Hilfe einer Schleife – zum Beispiel – alle Elemente ausgeben.

int[] zahlArray = {5, 2, 3, 4};
 
for(int i = 0; i < zahlArray.length; i++)
{
  System.out.println(zahlArray[i]);
}

Hierbei erzeugen wir wie in den obigen Beispielen das Array zahlArray und befüllen es mit den entsprechenden Werten. Mit der for-Schleife ist es uns nun möglich auf die Indizes von 0 bis 3 (zahlArray.length – 1) zuzugreifen.
Versuchen wir auf ein Element zuzugreifen, dass außerhalb des Arrays liegt – also wenn wir bei uns auf zahlArray[4] zugreifen würden – bekommen wir eine ArrayIndexOutOfBoundsException Fehlermeldung.

Wie in anderen Programmiersprachen ist es uns in Java auch möglich mehrdimensionale Arrays zu erstellen. Mehrdimensionale Arrays kann man sich als Arrays von Arrays vorstellen. Somit könnten wir beispielsweise Koordinaten speichern und auf diese zugreifen, oder uns eine Matrix simulieren.
Dies erfolgt folgendermaßen:

int[][] matrixEins = new int[2][3];
 
//Alternativen
int[] matrixZwei[] = new int[2][3];
int matrixDrei[][] = new int[2][3];

Mit diesem Code haben wir uns so gesehen drei Matrizen erzeugt, die jeweils aus zwei Zeilen und drei Spalten bestehen. Nun kommen wir zur Verwendung eines dieser mehrdimensionalen Arrays:

int[][] matrixEins = new int[2][3];
matrixEins[0][0] = 1;
matrixEins[0][1] = 1;
matrixEins[0][2] = 1;
matrixEins[1][0] = 2;
matrixEins[1][1] = 2;
matrixEins[1][2] = 2;
 
for(int i = 0; i < matrixEins.length; i++)
{
  int[] row = matrixEins[i];
 
  for(int j = 0; j < row.length; j++)
  {
    System.out.print(row[j]);
  }
  System.out.println();
}

Zunächst erzeugen wir uns wie schon weiter oben beschrieben ein zweidimensionales Array und befüllen es mit den Werten 1 und 2. Danach durchlaufen wir dieses Array mit zwei ineinander geschachtelten for-Schleifen, um auch alle Elemente zu erwischen. Dazu müssen wir uns ein neues Array anlegen, dass die jeweilige Zeile enthält und durchlaufen dieses neue Array mit der zweiten for-Schleife, um uns die Werte auszugeben, die in der aktuellen Zeile stecken. Ist diese Schleife abgearbeitet, wird dem row-Array die zweite Zeile des matrixEins-Arrays zugewiesen und die innere Schleife wird noch einmal abgearbeitet. Als Ausgabe wollten wir etwas sehen wie:

111
222

Ein letztes Thema in diesem Tutorial ist die erweiterte for-Schleife, die von den Java-Entwicklern erstellt worden ist, um uns ein wenig Tipparbeit abzunehmen.
Mit der erweiterten for-Schleife könnten wir unseren obigen Code in das umwandeln:

int[][] matrixEins = new int[2][3];
 
matrixEins[0][0] = 1;
matrixEins[0][1] = 1;
matrixEins[0][2] = 1;
matrixEins[1][0] = 2;
matrixEins[1][1] = 2;
matrixEins[1][2] = 2;
 
for(int[] row : matrixEins)
{
  for(int value : row)
  {
    System.out.print(value);
  }
 
  System.out.println();
}

Vom Prinzip her funktioniert die erweiterte for-Schleife wie die normale for-Schleife, unterscheidet sich jedoch in der Syntax:

for( Typ Bezeichner : Array )
{
…
}

Die erweiterte for-Schleife wird solange durchlaufen, bis das ganze Array abgearbeitet ist. Dabei wird der Variablen vor dem Doppelpunkt immer der aktuelle Wert aus dem Array übergeben, den wir zum Beispiel ausgeben können. Ist der Code im Rumpf abgearbeitet, wird der Variablen der nächste Wert, der im Array steckt übergeben, der dann wieder verarbeitet werden kann.

Somit hätten wir das Kapitel der Arrays in Java bearbeitet und können nun unsere Kuh vom Anfang endlich zum sprechen bringen. Dies jedoch im nächsten Tutorium.

Ansonsten bei Fragen fragen.

Bedingte Anweisungen sind gar nicht so schwer – also fangen wir gleich mit der if-Anweisung an:

int meinAlter = 55;
int rentenalter = 66;
 
if(meinAlter != rentenalter)
{
  System.out.println("Rentenalter nicht erreicht – weiterackern!");
}

Was macht dieses Programm nun? Wir setzen uns zwei Variablen mit den Werten 55 und 66. Die Variable meinAlter soll das jetzige Alter repräsentieren. Die Zweite enthält das gegenwärtige Rentenalter 66. Darunter sehen wir die if-Anweisung, die – wie jede if-Anweisung – mit dem Schlüsselwort if eingeleitet wird und in Klammern einen boolschen Wert enthält.

Hä, ich sehe aber gar keinen boolschen Wert?! Auf den ersten Blick erkennt man dies auch nicht sofort, doch der Operator != vergleicht zwei Werte auf Nicht-Gleichheit und liefert uns einen boolschen Wert als Ergebnis. Als Gegenstück dazu gibt es den == Operator, der zwei Werte auf Gleichheit hin überprüft. In unserem Fall würde es bedeuten, dass wir den Wert der Variablen meinAlter mit dem Wert der Variablen rentenalter vergleichen. Wir fragen uns also: “Ist der Wert der Variablen meinAlter ungleich des Wertes der Variablen rentenalter?”. Als Ergebnis bekommen wir von Java ein true – also es ist wahr, dass beide ungleich sind.
Da diese Bedingung nun wahr ist, wir der Code, der sich unterhalb der if-Anweisung in den geschweiften Klammern befindet ausgeführt.
In normaler Sprache ausgedrückt, könnte man diese Bedingung auch schreiben als: “Wenn meinAlter ungleich rentenalter ist, dann gib mir aus ‘Rentenalter nicht erreicht – weiterackern!’”.

Natürlich ist diese Bedingung nicht gut programmiert, denn wenn meinAlter einen Wert enthält, der größer als 66 ist, wir die Meldung ebenfalls ausgegeben. Stattdessen sollten wir den < Operator benutzen, der wie in der Mathematik prüft, ob der erste Wert kleiner dem zweiten Wert ist.

int meinAlter = 55;
int rentenalter = 66;
 
if(meinAlter < rentenalter)
{
  System.out.println("Rentenalter nicht erreicht – weiterackern!");
}

So ist der Code schon viel besser. Was ist, wenn wir aber auch etwas ausführen möchten, wenn die if-Anweisung nicht zutrifft? Dafür gibt es eben die if-/else-Anweisung. Fügen wir nun unserem if- einen else-Zweig hinzu.

int meinAlter = 55;
int rentenalter = 66;
 
if(meinAlter < rentenalter)
{
  System.out.println("Rentenalter nicht erreicht – weiterackern!");
}
else
{
  System.out.println("Yay, jetzt ist erstmal ausruhen angesagt!");
}

Ins else wird immer nur dann gesprungen, wenn das if nicht zutrifft. Bei uns würde eben die if-Anweisung zuschlagen, da unsere meinAlter-Variable kleiner ist als die rentenalter.
Ändern wir nun meinAlter zum Beispiel in 80, so würde die if-Anweisung nicht mehr zutreffen und dem Else-Zweig Beachtung geschenkt werden.

Es sind auch verschachtelte Fallunterscheidungen möglich:

int meinAlter = 1000;
int rentenalter = 66;
 
if(meinAlter < rentenalter)
{
  System.out.println("Rentenalter nicht erreicht – weiterackern!");
}
else
{
  if(meinAlter >= 969)
  {
      System.out.println("Na, willst du Methusalem Konkurrenz machen?");
  }
  else
  {
      System.out.println("Yay, jetzt ist erstmal ausruhen angesagt!");
  }
}

Wir haben meinAlter auf 1000 geändert. Da jetzt die Bedingung der if-Anweisung nicht zutrifft, wird in die else-Anweisung gesprungen. Darin befindet sich nun ebenfalls eine if-/else-Anweisung. Innerhalb des else-Zweiges, wird jetzt im if geprüft, ob meinAlter größer oder gleich 969 ist. Dies trifft nun zu und es wir die entsprechende Nachricht ausgegeben.
Für solch einen Fall bietet uns Java ein besonderes Konstrukt. Wir hätten also auch schreiben können:

int meinAlter = 1000;
int rentenalter = 66;
 
if(meinAlter < rentenalter)
{
  System.out.println("Rentenalter nicht erreicht – weiterackern!");
}
else if(meinAlter >= 969)
{
      System.out.println("Na, willst du Methusalem Konkurrenz machen?");
}
else
{
  System.out.println("Yay, jetzt ist erstmal ausruhen angesagt!");
}

Die else-if-Anweisung ist eine Kombination der if – und else-Anweisung. Denn trifft nun der if-Fall bei uns nicht zu, dann wird der else-if-Fall überprüft. Trifft dieser auch nicht zu, wird else ausgeführt. Als Anmerkung sei noch gesagt, dass es uns möglich ist, so viele else-if-Fälle zu benutzen wie wir wollen.

Neben der if-Anweisung und der if-/else-Anweisung findet man die switch-Anweisung:

int meinAlter = 1000;
switch(meinAlter)
{
  case 0:
    System.out.println("Na, heute Windeln schon gewechselt bekommen?");
  break;
 
  case 66:
    System.out.println("Du darfst in Rente gehen!");
  break;
 
  case 969:
    System.out.println("Methusalem lässt grüßen");
  break;
 
  case 4723:
    System.out.println("Der Methuselah-Baum ist so alt wie du – Respekt!");
  break;
 
  default:
    System.out.println("Ja, schönes Alter!");
  break;
}

Der switch-Anweisung wird zunächst ein Wert übergeben. Dieser wir dann überprüft, ob er sich einem bestimmten Fall (case) zuordnen lassen kann. Ist dies nicht möglich, wird der default-Fall angewandt. Der default-Fall ist optional und kann auch weggelassen werden. Bei switch ist zu beachten, dass die break-Anweisungen gesetzt sind. Ein Break bedeutet, dass nach Aufruf der break-Anweisung der weitere Durchlauf einer Anweisung abgebrochen wird. Wird ein Break bei der switch-Anweisung vergessen, so erzeugen wir einen Fall-Through. Es wird jetzt nicht abgebrochen sobald ein Fall eingetroffen ist, sondern es werden die weiter unten stehenden Fälle auch überprüft.

Jetzt müssen wir nur noch etwas über Arrays erfahren und wir können unser CowSay-Programm zum “Sprechen” bringen.