/**
 * Klasse Programm soll die Verwendung von Methoden verdeutlichen.
 */
class Programm {
    /**
     * Methode add addiert zwei uebergebene Parameter und gibt die Summe zurueck
     * @param summand_1 Der erste Summand
     * @param summand_2 Der zweite Summand
     * @return Das Ergebnis der Addition beider  Summanden
     */
    public static int add(int summand_1, int summand_2){
        return summand_1 + summand_2;
    }
 
    /**
     * Methode hallo gibt ihren Namen aus. Welche weitere Methode sie aufgerufen hat und
     * welches Ergebnis sie von der anderen Methode erhalten hat.
     */
    public static void hallo(){
        System.out.println("Ich bin die Methode \"hallo\"");
        System.out.println("Ich rufe die Methode \"add\" mit den Parametern 3 und 4 auf");
        int summe = add(3, 4);
        System.out.println("Ich habe als Ergebnis die Summe " + summe + " von \"add\" erhalten");
    }
    /**
     * Main-Methode wird vom Compiler gesucht und automatisch aufgerufen
     */
    public static void main(String[] args) {
        System.out.println("Das ist ein Beispiel, das die Verwendung von Methoden erklaeren soll");
        hallo();
        System.out.println("Hier endet die main-Methode und damit das Programm");
    }
}

Dieses Programm enthält insgesamt drei Methoden, die wir definiert haben. Zunächst ist da die bereits bekannte main-Methode. Diese wird beim Kompilieren und beim Ausführen des Programms gesucht und automatisch aufgerufen. Sie ermöglicht also der JVM den Einstieg in unser Programm. Ohne ihr würde nichts funktionieren. Wichtig ist, dass ein Programm nur eine main-Methode haben darf, da sonst nicht klar ist, welche dieser Methoden ausgeführt werden sollen.
Die zweite Methode ist die Methode “hallo”. Sie ähnelt in ihrem Methodenkopf sehr stark der main-Methode. Der einzige Unterschied ist, dass unsere hallo-Methode keine Parameter übergeben bekommt. Parameter sind die Elemente, die von der runden öffnenden und schließenden Klammer, die hinter der Bezeichnung der Methode kommt, eingeschlossen werden. Zu erkennen ist, dass die main-Methode einen Parameter mit der Bezeichnung “args” übergeben bekommt. Dieser Parameter ist vom Typ ein String-Array.

Die Methode “hallo” ruft in Zeile 22 eine weitere Methode auf, die wir “add” genannt haben. Das Ergebnis, dass uns die Methode “add” liefert, wird der Variablen “summe” zugewiesen. Der Wert der Variablen wird dann in der drauf folgenden Zeile ausgegeben.
Die Methode “add” addiert die beiden übergebenen Parameter. Das Ergebnis der Addition wird dann zurückgegeben. Das Zurückgeben erfolgt stets mit dem Schlüsselwort “return”. Sobald wir etwas zurückgeben möchten, müssen wir im Methodenkopf notieren welchen Typ die Rückgabe haben wird. Deshalb steht vor der Bezeichnung der add-Methode das Schlüsselwort “int”. Zurückgegeben werden können alle erdenklichen Typen wie int, long, float, double, String, Arrays und Objekte. Da wird in der Methode “hallo” nichts zurückgeben wollen, sondern nur Ausgaben tätigen, muss vor dem Methodennamen das Schlüsselwort “void” stehen. Es heißt soviel wie “Ich geben nichts zurück”. Die main-Methode darf per Konvention nur void sein.

Was ist nun der Sinn hinter Methoden? Methoden dienen dazu, um Code durch Auslagern übersichtlicher und wartungsfreundlicher zu gestalten.

Methoden werden nacheinander wie sie im Programm aufgerufen werden abgearbeitet. Methoden, die andere Methoden aufrufen, werden unterbrochen und fahren erst nachdem die aufgerufene Methode beendet ist, in ihrem Programmfluss fort. In unserem Beispiel wird zunächst du die JVM die main-Methode ausgeführt. In dieser Methode rufen wir die Methode “hallo” auf. Somit wird die Methode main zunächst unterbrochen und die hallo-Methode ausgeführt. Methode “hallo” ruft wiederum die Methode “add” auf, der sie die zwei Parameter 3 und 4 übergibt, um dann den eigenen Programmfluss zu unterbrechen und den Weg für “add” frei zu machen. Nachdem “add” die beiden Parameter addiert hat, kann “hallo” fortfahren und ebenfalls beendet werden. Jetzt wird weiter die Methode “main” ausgeführt, bis diese abgearbeitet wurde und unser Programm schließlich beendet werden kann.
Den Programmfluss soll das nachfolgende Bild darstellen.

Programmfluss der Methoden

cowsay 'Java rocks!'

Die Ausgabe dazu sollte so aussehen:

 _____________
< Java rocks! >
 -------------
           ^__^
           (oo)_______
           (__)       )/
              ||----w |
              ||     ||

Diese Funktionalität möchten wir nun nachbauen, dass wir unser cowsay mit diesem Befehl ausführen können und das Ergebnis genauso aussehen soll wie das original cowsay aus Unix.

java cowsay 'Java rocks!'

Der Vorteil dabei ist jedoch, dass wir dieses Programm auf Windows, Linux, Mac OSX und allen anderen Betriebssystemen nutzen können, die auch von dem Java Runtime Environment unterstützt werden.
Okay, fangen wir dann mal an. Zunächst erstellen wir uns eine Klasse cowsay, die auch die main-Methode enthält:

class cowsay
{
  public static void main(String[] args)
  {
  }
}

Zunächst sollten wir klären wie wir es schaffen, dass der Text, den wir beim Aufruf des cowsay-Programms mitgeben auch in unseren Java-Code kommt. Dazu ist dieses String[] args da! Wie wir in den letzten Tutorials gelernt haben, handelt es sich hierbei um ein Array des Typs String. Darin finden wir die Argumente, die wir an unser Programm in der Konsole übergeben haben. Bei unserem cowsay brauchen wir lediglich auf args[0] zuzugreifen, denn wir übergeben nur ein Argument. Sollten wir jedoch mehrere Argumente übergeben wollen, so trennen wir diese durch ein Leerzeichen im Programmaufruf und finden diese in args[0] … args[n] wieder. Je nachdem wie viele davon wir übergeben hatten.
Ein Problem auf das wir stoßen werden, ist dass wir die Fehlermeldung “ArrayIndexOutOfBoundException” erhalten, wenn wir beim Programmaufruf keine Nachricht übergeben. Dies werden wir mit einer bedingten Anweisung lösen und eine Standardnachricht angeben.
Deshalb waren mir auch die letzten Tutorials so wichtig, bevor wir dieses hier bearbeiten konnten.
Bauen wir uns dazu nun folgenden Code:

class cowsay
{
  public static void main(String[] args)
  {
    if(args.length == 0)
    {
      args = new String[1];
      args[0] = "Ich sage nix";
    }
    //Hier geht es noch weiter
  }
}

Hier prüfen wir mit args.length == 0, ob das args Array einen Wert zugewiesen bekommen hat. Ist dies der Fall, so ist die Länge des Arrays größer 0! Sollte es nun so sein, dass keine Nachricht eingegeben wurde, definieren wir args als ein String-Array-Objekt mit einer Länge von eins. Nun speichern wir die Standardnachricht “Ich sage nix” in das Array an der Stelle 0.

Wenden wir uns jetzt der Sprechblase zu. Wir müssen dabei darauf achten, dass die Größe dieser abhängig von der Länge der eingegeben Nachricht ist. Dieses Problem werden wir mit einer Schleife lösen können. Dies zeigt uns das folgende Code-Fragment:

class cowsay
{
  public static void main(String[] args)
  {
    if(args.length == 0)
    {
      args = new String[1];
      args[0] = "Ich sage nix";
    }
    String message = args[0];
    int messageLength = message.length();   //Laenge der Nachricht
 
    /*********************************************
    *           Sprechblase erzeugen
    *********************************************/
    String top = " ";                //Obere Linie der Sprechblase
    String bottom = " ";             //Untere Linie der Sprechblase
 
    //Linke und rechte Grenze mit Nachricht der Sprechblase
    String contentAndBorders = "< " + message + " >";
 
    //Gesamte Sprechblase
    String speechBubble;
 
    //Obere + untere Linie erzeugen
    for(int i = 1; i <= messageLength + 2; i++)
    {
      top += "_";
      bottom += "-";
    }
 
    speechBubble = top + "n";
    speechBubble += contentAndBorders + "n";
    speechBubble += bottom + "n";
 
    //Jetzt folgt noch die Kuh
  }
}

Die ersten Zeilen sind die gleichen wie im obigen Code. Wir weisen der Variablen message den Inhalt des Arrays an der Stelle 0 zu, damit wir uns das Schreiben der eckigen Klammern sparen können und diese Variable einfach sprechender ist, als ein args[0].
Die Variable messageLength bekommt die Länge unserer Nachricht zugewiesen, da wir diese für die Schleife brauchen werden. Als nächstes erzeugen wir uns die Variablen top und bottom, die die Zeichen für die obere bzw. untere Linie enthalten werden. Diese bekommen jeweils zunächst ein Leerzeichen zugewiesen. Damit stellen wir sicher, dass über / unter der öffnenden spitzen Klammer keine Striche stehen werden.
Die Variable messageAndBorders enthält die Nachricht und den linken und rechten Begrenzer gefolgt von einem Leerzeichen, damit links und rechts von der Nachricht etwas Platz bleibt. – Sieht einfach besser aus. Dadurch müssen wir aber auch die Schleife um zwei Durchläufe erweitern, um dies auszugleichen. In dieser Schleife werden die Variablen top und bottom mit den entsprechenden Zeichen “_” und “-” gefüllt. Es werden so viele Zeichen erstellt wie die Nachricht – verlängert um zwei – lang ist.
Die Variable speechBubble soll die gesamte Sprechblase enthalten und bekommt deshalb top, contentAndBorders und bottom – jeweils gefolgt von einer “newline” – zugewiesen.

Jetzt fehlt uns nur noch die Kuh. Eigentlich könnten wir einfach den Code aus dem CowSay-Tutorial verwenden, denn es ändert sich hierbei nichts. Um aber so viele System.out.println zu vermeiden, speichern wir die Kuh in die kuh Variable und erstellen uns eine Variable cowsay, die die Sprechblase und die Kuh enthält, die wir dann schließlich ausgeben werden.

class cowsay
{
  public static void main(String[] args)
  {
    if(args.length == 0)
    {
      args = new String[1];
      args[0] = "Ich sage nix";
    }
    String message = args[0];
    int messageLength = message.length();   //Laenge der Nachricht
 
    /*********************************************
    *           Sprechblase erzeugen
    **********************************************/
    String top = " ";                //Obere Linie der Sprechblase
    String bottom = " ";             //Untere Linie der Sprechblase
 
    //Linke und rechte Grenze mit Nachricht der Sprechblase
    String contentAndBorders = "< " + message + " >";
 
    //Gesamte Sprechblase
    String speechBubble;
 
    //Die Kuh
    String kuh;
 
    //Die gesamte Ausgabe
    String cowsay;
 
    //Obere + untere Linie erzeugen
    for(int i = 1; i <= messageLength + 2; i++)
    {
      top += "_";
      bottom += "-";
    }
 
    speechBubble = top + "n";
    speechBubble += contentAndBorders + "n";
    speechBubble += bottom + "n";
 
    //Die Kuh erzeugen
    kuh = "          ^__^" + "n";
    kuh += "          (oo)_______" + "n";
    kuh += "           (__)       )/" + "n";
    kuh += "               ||----w |" + "n";
    kuh += "               ||     ||";
 
    cowsay = speechBubble + kuh;
 
    System.out.println(cowsay);
  }
}

Jetzt ist unsere Kuh eigentlich fertig und kann auch verwendet werden. Wir werden sie aber noch in späteren Tutorials umbauen. Freut euch schon mal drauf.

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.

int i = 0;
System.out.println(i);    //Ausgabe: 0
i++;
System.out.println(i);    //Ausgabe: 1
i++;
System.out.println(i);    //Ausgabe: 2
i++;
System.out.println(i);    //Ausgabe: 3

Wie wir sehen, erzeugen wir uns zunächst eine Variable, die einen Wert von 0 zugewiesen bekommt und dann der Wert der Variablen ausgegeben wird. Danach wird der Wert der Variablen um eins erhöht und es erfolgt wieder eine Ausgabe … usw. Nun, da Programmierer schreibfaul sind und dieser Code einfach zu umständlich erscheint, gibt es in vielen Programmiersprachen Schleifen, die dazu dienen einen bestimmten Code mehrmals auszuführen. Programmiersprachen, die keine Schleifen unterstützen, verwenden oft das Konzept der Rekursion – dies unterstützt Java auch.

Java kennt hierbei drei Arten von Schleifen:

• while-Schleife
• do-while-Schleife
• for-Schleife

Schleifen bestehen immer aus einer Schleifenbedingung und dem Rumpf. In der Schleifenbedingung befindet sich ein boolescher Ausdruck, der der Schleife sagt wie lange der im Rumpf stehende Programmcode wiederholt werden soll.

Wenden wir uns zunächst der while-Schleife zu und betrachten dazu den oben abgewandelten Code in “Schleifen-Schreibweise”:

int i = 0;
while(i <= 3)
{
  System.out.println(i);
  i++;
}

Compilieren wir nun dieses Code-Fragment, so sollten wir das gleiche Ergebnis wie oben erhalten. Doch was passiert nun hier? Zunächst erstellen wir wie oben die Variable i und weisen ihr den Wert 0 zu. Danach sehen wir die while-Schleife in Gebrauch. In den runden Klammern finden wir die Bedingung, die der Schleife sagt, wie lange sie wiederholt werden soll – nämlich so lange wie unser i kleiner-gleich drei ist. Nun gelangen wir in den Rumpf der Schleife. Wie wir sehen findet dort lediglich die Ausgabe von i statt. Danach wird i um eins erhöht. Das Erhöhen der Variablen dürfen wir nicht vergessen, denn sonst bekämen wir eine Endlosschleife, die theoretisch unendlich lang ausgeführt wird. Naja, Theorie und Praxis sehen hierbei anders aus, denn entweder erkennt unser Betriebssystem, dass es sich hier um Code handelt, der nicht vorwärts kommt und bricht diesen ab, oder wir brechen ihn selber ab, weil es uns zu doof ist so lange zu warten, oder uns schmiert irgendwann das System ab und wir müssen den Rechner neu starten.
Schauen wir uns nun den obigen Code umgewandelt in eine for-Schleife an:

for(int i = 0; i <= 3; i++)
{
  System.out.println(i);
}

Was macht nun dieses Stück Code? In der for-Schleife deklarieren wir die Variable in den runden Klammern und weisen ihr den Wert 0 zu. Nach dem Semikolon folgt dann die Bedingung, die die gleiche ist wie bei der while-Schleife. Ein Semikolon weiter schreiben wir das rein, was mit unserer Zählvariablen i gemacht werden soll – sie wird um eins erhöht.
Die Syntax einer for-Schleife sieht folgendermaßen aus:

for(Zählvariable; Bedingung; Erhöhung der Zählvariablen)
{
Code im Rumpf
}

Der Code im Rumpf der Schleife wird so lange wiederholt, bis i den Wert von drei übersteigt.

Jetzt tun uns noch die do-while-Schleife und haben dieses Kapitel auch hinter uns
Zunächst einmal wenden wir uns wieder einem Code-Beispiel zu:

do
{
  System.out.println(i);
  i++;
}
while(i <= 3);

Okay, die do-while-Schleife unterscheidet sich von der while-Schleife einmal, dass da das “do” vor dem “while” steht und dadurch, dass eine do-while-Schleife mindestens einmal ausgeführt wird. Haben wir also eine Bedingung, die von vornherein “false” ist, so findet bei der while- und der for-Schleife keine Ausführung des Codes im Rumpf statt – jedoch bei der do-while-Schleife.

Nun sollte sich die Frage stellen wann man welche Schleife verwenden sollte. Bei der do-while-Schleife sollte es klar sein, dass man diese nutzt, um Code mindestens einmal ausgeführt zu haben. Bei der for- und while-Schleife ist es Wurschd, denn vom Aufwand her sollten beide gleich sein.

Also, noch ein fröhliches Coden … =)

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.

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.

“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:

Variablen werden viele schon aus der Mathematik kennen. Schauen wir und beispielsweise eine einfache Gleichung aus der Algebra an.
x² + 2x = 0
Dabei ist x eine Variable, die für verschiedene Zahlen steht. Dass x die Werte 0 und -2 annehmen kann, damit die Gleichung auch korrekt ist, ist hier unwichtig.

Eine Variable in der Programmierung kann man sich als Box vorstellen, in die wir verschiedenste Werte reinstecken und diese dann wieder auslesen oder verändern können.

Die Variable ist eine Box, die den Namen “zahl” trägt. In diese Box können wir nun zum Beispiel eine Zahl “hineinschieben” – hier ist es die 5. Später können wir auf diese gespeicherte 5 zugreifen, indem wir einfach dazu den Namen der Variablen verwenden.

Dies wollen wir nun in Java mit folgendem Code übertragen.

int zahl;
zahl = 5;

In der ersten Zeile sagen wir dem Compiler, dass wir eine Variable zahl in unserem Programm haben werden. In der zweiten Zeile weisen wir der Variablen zahl den Wert 5 zu.
Den obigen Code können wir so auch verkürzt aufschreiben:

int zahl = 5;

Jetzt kann man beim weiteren Programmieren auf diese Variable zugreifen, sie verändern oder mit ihr Rechnungen durchführen. Dazu dieses Beispiel:

class VariablenTutorial
{
  public static void main(String[] args)
  {
    int zahl = 5;
    System.out.println("Ich bin die Variable zahl! Mein Wert ist: " + zahl);
    zahl = 3;
    System.out.println("Ich bin die Variable zahl! Mein Wert ist: " + zahl);
    zahl = zahl + 3;
    System.out.println("Ich bin die Variable zahl! Mein Wert ist: " + zahl);
  }
}

Die Ausgabe dieses Programmes sollte wie folgt aussehen:

Ich bin die Variable zahl! Mein Wert ist: 5
Ich bin die Variable zahl! Mein Wert ist: 3
Ich bin die Variable zahl! Mein Wert ist: 6

Was geschieht nun in unserem Programmablauf?
In der ersten Zeile der main-Methode erstellen wir eine Variable zahl, die den Wert 5 zugewiesen bekommt. Danach rufen wir System.out.println() mit einem Text auf und übergeben unsere Variable. In der dritten Zeile überschreiben wir unsere Variable mit einem neuen Wert und geben wieder eine Meldung auf der Konsole aus. In der fünften Zeile rechnen wir mit dieser Variable. Der Wert der Variable zahl, der jetzt 3 ist, wird mit 3 addiert und das Ergebnis wird wieder in unsere Variable zahl gespeichert. Eine erneute Ausgabe auf der Konsole zeigt uns, dass die Variable zahl jetzt den Wert 6 angenommen hat.
Was dieses “int” da vor der Variable zu suchen hat, klären wir im nächsten Tutorial. Freut euch drauf!

cowsay "Java rocks!"

Die Ausgabe sollte in etwa so aussehen:

 _____________
< Java rocks! >
 -------------
          ^__^
          (oo)_______
           (__)       )/
               ||----w |
               ||     ||

Falls ihr aber Windows benutzen solltet, so braucht ihr nicht enttäuscht zu sein, denn wenn ihr diesem Link folgt (CowSay), findet ihr ein CowSay als Web-Applikation. Wie es scheint, findet sich cowsay auf Mac OSX nicht automatisch vorinstalliert. Will man dieses Programm unbedingt auf dem Rechner haben, so kann man es sich über die DarwinPorts oder MacPorts nachinstallieren. Danke an Martin für diesen Hinweis.

Nun wollen wir mit unserem Java CowSay beginnen. Wir werden für jede Zeile eine System.out.println()-Anweisung mit dem entsprechenden Inhalt schreiben. So würde beispielsweise der Aufruf für die erste Zeile lauten

System.out.println(" _____________");

Das wollen wir nun für jede Zeile fortführen. Diesen Code packen wir in der Klasse CowSay in die Methode main(). Dann sollte unser Quelltext wie folgt aussehen

public class CowSay
{
  public static void main(String[] args)
  {
    System.out.println(" _____________ ");
    System.out.println("< Java rocks! >");
    System.out.println("          ^__^");
    System.out.println("          (oo)_______");
    System.out.println("           (__)       )/");
    System.out.println("               ||----w |");
    System.out.println("               ||     ||");
  }
}

Euch wird sicher auffallen, dass wir statt einem Backslash ( ) zwei Backslashes ( ) hintereinander geschrieben haben. Dies liegt daran, dass das Backslash in Java – und einigen anderen Programmiersprachen auch – ein Escape-Zeichen ist, womit bestimmte Escape-Sequenzen eingeleitet werden. Was Escape-Sequenzen sind behandeln wir in einem weiteren Tutorial.

Unseren Quellcode speichern wir analog zu unserem HalloWelt-Tutorium unter CowSay.java, compilieren diese Datei mit dem Java Compiler und führen den entstandenen Bytecode aus.

javac CowSay.java
java CowSay

Und siehe da, wir haben nun eine Kuh auf unserer Konsole. Okay, zugegeben hat unsere Kuh noch einen recht kleinen Wortschatz, denn sie kann immer nur “Java rocks!” ausgeben (deshalb auch “CowSay (naiv)”). Dies wird sich aber im Laufe der nächsten Tutorials ändern. Also seid gespannt auf die kommenden Java-Tutorials!