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 … =)