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.

Java bietet uns drei Möglichkeiten von Kommentaren:

• Zeilenkommentar
• Blockkommentar
• JavaDoc-Kommentar

Ein Zeilenkommentar gilt nur für eine Zeile und wird mit einem // eingeleitet. Möchte man Kommentare über mehrere Zeilen hinweg setzten, so bietet sich das Blockkommentar dafür an. Dieses wird mit einem /* eingeleitet und endet mit */.
Das JavaDoc-Kommentar ist ein besonderes Blockkommentar, das zum Beispiel Beschreibungen von Funktionen und / oder deren Parameter enthält. Beginnt man ein Kommentar mit /** und schließt es mit */ ab, handelt es sich um diesen Typ von Kommentar. Mit dem im JDK mitgelieferten Tool javadoc ist es möglich diese Kommentare zu einer API-Dokumentation zu generieren.

Mit Kommentaren können wir Code auch zum Testen und zur Fehlersuche auskommentieren, um diese vor dem Compiler zu verstecken.

Dieses Beispiel soll uns die Verwendung von Kommentaren in Java verdeutlichen:

/**
 * @author eugen
 * @version 1.0
 */
class RasenMaehen
{
  /*
  * Dieses Programm berechnet, ob man seinen Rasen mähen sollte
  */
  public static void main ( String[] args )
  {
    //Maße in cm
    int aktuelleLaenge = 53;
    int gewuenschteLaenge = 20;
    int maxUeberschuss = 10;
 
    // Wenn Ueberschuss zu groß, muss gemaeht werden
    if( (aktuelleLaenge – gewuenschteLaenge) > maxUeberschuss )
    {
      System.out.println("Rasen muss gemaeht werden");
    }
    else
    {
      System.out.println("Geht noch!");
    }
  }
}

Bei dem ersten Kommentar handelt es sich um einen JavaDoc-Kommentar, der besondere Schlüsselwörter wie @author enthält, die vom javadoc-Tool ausgewertet werden können.
Der zweite Kommentar auf den wir stoßen ist ein Blockkommentar, der sich über drei Zeilen hinzieht.
Bei dem dritten und vierten Kommentar verwenden wir nun den Zeilenkommentar, der wie gesagt nur eine Zeile auskommentiert.

int ersteVariable = 5;
int zweiteVariable;
zweiteVariable = ersteVariable * 2;

Wir deklarieren uns die zwei Variablen ersteVariable und zweiteVariable. Der erstenVariable weisen wir den Wert 5 zu. Die zweiteVariable bekommt ein Ergebnis einer mathematischen Formel zugewiesen.
Wo stehen nun die Operatoren? Der erste Operator, der zum Einsatz kommt, ist der Zuweisungsoperator =, der beispielsweise einer Variablen, die vor diesem Operator steht, einen bestimmten Wert, der dahinter kommt, zuweist.
Einen weiteren Operator finden wir in der Multiplikation. Der * – Operator multipliziert zwei Werte miteinander. Die Variable ersteVariable und die Zahl 2 werden hierbei als Operanden bezeichnet.
In Java findet man im Grunde drei Arten von Operatoren. So gibt es die unären Operatoren, die nur auf einen Operanden Anwendung finden. Der große Bruder davon ist der binäre Operator, oder auch zweistellige Operator. Diese sind beispielsweise Operatoren, die in der Mathematik gebraucht werden – also Plus, Minus, Mal und Geteilt. Wie man auch vermuten kann, kommt jetzt der dreistellige Operator. So gibt es auch den Fragezeichenoperator (?-Operator), der zur Fallunterscheidung genutzt werden kann:
Syntax: Bedingung ? Dann-Fall : Sonst-Fall
Mit Operatoren ist es uns möglich einzelne Ausdrücke zu neuen Ausdrücken zu verbinden – wie in der Mathematik bei der Addition. Operatoren, die zur üblichen Rechnung genutzt werden, bezeichnet man auch als arithmetische Operatoren (+, -, *, /, %). Der %-Operator, oder auch Modulo-Operator / Restwert-Operator gibt uns den Rest einer Division zurück. So bekämen wir bei dem Ausdruck 5 % 3 als Ergebnis die Zahl 2, denn 5 / 3 = 1 Rest 2.

Weiter oben haben wir den Zuweisungsoperator = kennen gelernt. Schauen wir uns diesen Code an:

int meinAlter = 55;
System.out.println("Ich habe Geburtstag!");
meinAlter = meinAlter + 1;
System.out.println("Mein neues Alter ist jetzt " + meinAlter);

Da der Informatiker relativ schreibfaul ist, finden wir in vielen Programmiersprachen – so auch in Java – die Verbundoperatoren. Diese verkürzen Ausdrücke wie meinAlter = meinAlter + 1 auf meinAlter += 1. Dies gilt auch für die Subtraktion (-=), Multiplikation (*=) und Division (/=).
In diesem Code hat sich aber auch noch ein weiterer Operator versteckt. Es ist das überladene Plus (+) für Strings. Damit ist es uns möglich etwas von beliebigem Typ an eine Zeichenkette zu hängen. In unserem Beispiel: im letzten Systen.out.println() wird die Zahl 55 aus meinAlter an den String “Mein neues Alter ist jetzt ” gehängt.
Zwei weitere Operatoren, die uns schreibfaule Informatiker unterstützen, sind die Präfix-Inkrement bzw. Postfix-Inkrement und Präfix-Dekrement bzw. Postfix-Dekrement Operatoren. Damit ist es uns möglich eine Zahl um eine Eins zu erhöhen bzw. zu verringern. Dazu wird beispielsweise vor oder hinter einer Variablen ein ++ oder ein — geschrieben.
So hätten wir auch anstatt

meinAlter = meinAlter + 1;

einfach schreiben können

meinAlter++

Hätten wir zufällig einen Jungbrunnen entdeckt, könnten wir auch schreiben

meinAlter--

Aus der Mathematik kennen wir auch Operatoren, wie Kleiner (<), Größer (>), Kleiner-gleich (<=), und Größer-gleich (>=). Diese können wir in Java als Vergleichsoperatoren verwenden und haben es auch schon im Java-Tutorial: Fallunterscheidungen getan. So haben wir geschrieben:

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

Hier haben wir verglichen, ob die Variable meinAlter kleiner ist als die rentenalter. Zwei weitere Vergleichsoperatoren sind == und !=. Damit ist es uns möglich zu überprüfen, ob zwei Werte gleich, oder ungleich sind. Alle Vergleichsoperatoren liefern uns als Ergebnis einen boolschen Wert, der entweder true oder false ist. So liefert uns beispielsweise meinAlter < rentenalter ein true, denn es ist wahr, dass meinAlter kleiner ist als das rentenalter. Schrieben wir meinAlter == rentenalter, bekämen wir ein false, denn meinAlter ist eben nicht gleich rentenalter. So liefert meinAlter != rentenalter wiederum true.
Widmen wir uns jetzt aber den logischen Operatoren AND (&&), OR(||), XOR (^) und dem Nicht (!) zu. Mit diesen Operatoren ist es uns möglich verschiedene boolsche Ausdrücke zu verknüpfen. Zum Beispiel ist es uns jetzt möglich zu überprüfen, ob meinAlter < rentenalter und zugleich meinAlter > 17 ist. In Java-Code geschrieben sieht das wie folgt aus:

meinAlter < rentenalter && meinAlter > 17

Der Ausdruck meinAlter < rentenalter liefert uns true, ebenso wie meinAlter > 17, somit ist der gesamte Ausdruck ebenfalls true, denn der AND-Operator liefert uns nur ein Wahr, wenn beide Ausdrücke, die miteinander verbunden werden auch wahr sind. Dagegen liefert uns der OR-Operator immer dann ein Wahr, wenn mindestens ein boolscher Ausdruck darin wahr ist, das uns folgender Code zeigt:

meinAlter < 17 || meinAlter < rentenalter

meinAlter < 17 ist falsch. Dagegen ist meinAlter < rentenalter wie bereits erwähnt wahr. Als Ergebnis liefert uns der ||-Operator ein true.
Möchte man dagegen das Oder aus dem üblichen Sprachgebrauch verwenden, das besagt, dass entweder dies oder das gilt, so wenden wir uns an den XOR-Operatoren. Der XOR-Operator liefert uns nur dann einen wahren Wert, wenn entweder der eine Ausdruck, oder der andere Ausdruck, die miteinander verknüpft werden, wahr sind.

meinAlter < rentenalter ^ meinAlter > 17

Dieser Ausdruck liefert uns false, denn sowohl meinAlter < rentenalter, als auch meinAlter > 17 sind wahr.
Der letzte Operator, den wir in diesem Java-Tutorial behandeln werden ist der Nicht-Operator. Er dreht einfach einen boolschen Wert um. So wird aus einem Wahr ein Falsch und umgekehrt.

!(meinAlter < 17)

Bei diesem Code bekommen wir also ein true, denn meinAlter < 17 liefert uns ein Falsch. Dieses wird durch den Nicht-Operator zu einem Wahr.
Damit haben wir das Kapitel Operatoren hinter uns gebracht und können uns anderen schönen Dingen in Java zuwenden.

“Aber was soll eigentlich dieses ‘int’ da?” hat man sich im Java-Tutorial: Variablen gefragt. Dieses “int” gibt den Typ unserer Variable aus. Es sagt dem Compiler erstmal wieviel Speicherplatz er reservieren muss und zweitens welche Daten man in diese Variable Speichern kann.

Dies führt uns zum Thema der Datentypen, denn genau dieses “int” ist ein Schlüsselwort für den Datentyp Integer in Java. Hat man eine Variable als Integer deklariert, so kann man nur ganzzahlige Werte darin Speichern. Also alle Zahlen, die kein Komma haben – wie unsere 5 aus dem Beispiel. Würden wir dennoch zum Beispiel versuchen die 5,5 darin zu speichern, bekämen wir eine Fehlermeldung zu Gesicht, denn die 5,5 ist eben keine Zahl aus dem Bereich der ganzen Zahlen.

Aber wie speichern wir nun reelle Zahlen (Zahlen mit Komma – auch Gleitkommazahlen)? Dazu müssen wir einen anderen Datentyp verwenden, nämlich den Datentyp Double oder Float. Der Unterschied zwischen den beiden Typen ist der Speicherplatz, der reserviert wird – bei Float weniger als bei Double (Float: 4 Bit / Double: 8 Bit). Somit können unterschiedlich lange Gleitkommazahlen gespeichert werden. Als Java-Code sieht das folgendermaßen aus:

double reelleZahl = 5.5;

Es ist darauf zu achten, dass in Java statt dem Komma ein Punkt bei reellen / Gleitkomma-Zahlen verwendet wird. Also statt 5,5 schreiben wir im Code 5.5, sonst bekämen wir wieder eine Fehlermeldung serviert.

Der Datentyp Boolean ist für Bool’sche Werte da. Bool’sche Werte sind Wahrheitswerte – also ob etwas wahr oder falsch, oder auf Englisch true oder false ist.

boolean wahrheitswertWahr = true;
boolean wahrheitswertFalsch = false;

Für einzelne Buchstaben verwendet man den Datentyp Char.

char einZeichen = 'a';

Hier ist darauf zu achten, dass einzelne Zeichen in einfache Anführungszeichen gesetzt werden müssen.

Natürlich kann man in Java auch mehr als nur einen Buchstaben in einer Variablen speichern. Dies bewerkstelligen wir wiederum mit einem neuen Datentyp – dem Datentyp String.

String eineGanzeReiheAnBuchstaben = "So können ganze Sätze gespeichert werden";

Hier nochmal die Datentypen in einer Übersicht: