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.

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.

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!

Zunächst einmal kann man jedes Java-Programm in einem stinknormalen Editor schreiben. Daneben gibt es auch Editoren, die bestimmten Code besonders hervorheben – das Syntax-Highlighting. Einige bekannte sind hier gedit für Gnome und kate für KDE. Beide für Linux-Betriebssysteme. Für Windows bietet sich beispielsweise das Notepad++ an.

Daneben gibt es auch sogenannte integrierte Entwicklungsumgebungen – die IDEs. Diese bieten in der Regel neben Syntax-Highlighting, einen Compiler bzw. Interpreter, einen Debugger, einen Linker und viele andere tolle Features. Bekannte Vertreter sind hierbei für Java NetBeans und eclipse. IDEs sind für Einsteiger jedoch nicht zu empfehlen, da sie unter anderem einem viel Arbeit vorweg nehmen, dies jedoch am Anfang den Lernerfolg eher behindert.

Kommen wir nun zu unserem ersten Programm – dem HelloWorld

public class HelloWorld
{
  public static void main(String[] args)
  {
    System.out.println("HelloWorld");
  }
}

Diesen Code speichern wir nun unter dem Dateinamen HelloWorld.java ab. Bei Java-Programmen ist darauf zu achten, dass Dateinamen mit dem Namen der Klasse identisch sind, da sonst ein Fehler erzeugt wird. Die genauen Bedeutungen der Aufrufe werden noch im Laufe der Zeit in den Tutorien geklärt. Aber eine kurze Beschreibung dürfte dennoch nicht schaden.

Wir erzeugen in der ersten Zeile eine Klasse mit dem Namen HelloWorld. In dieser Klasse definieren wir die Methode main. Die main-Methode in Java ist ein besonderes Konstrukt und wird deshalb auch speziell behandelt. In der fünften Zeile erzeugen wir die Bildschirmausgabe HelloWorld mit dem Befehl System.out.println(“HelloWorld”);. Dabei wird am Ende automatisch in eine neue Zeile gesprungen.

Jetzt wollen wir unser kleines HelloWorld-Programm noch compilieren und dann ausführen.

Den ersten Schritt erledigen wir mit dem im Java Development Kit (JDK) mitgelieferten Java Compiler. Dazu lautet der Befehl, den wir in der Konsole / Eingabeaufforderung eingeben müssen wie folgt. Beim Compilieren erstellt uns der Java Compiler aus unserer HelloWorld.java den sogenannten Bytecode. Dabei wird die Datei HelloWorld.class erzeugt, die man auf allen Betriebssystemen lauffähig sein sollte. Vorausgesetzt, auf dem anderen Betriebssystem ist mindestens das Java Runtime Environment (JRE) installiert.

javac HelloWorld.java

So, haben wir nun keine Fehlermeldung ausgegeben bekommen, ist alles gut gelaufen und wir können nun mit der Ausführung unseres Programms jetzt fortfahren. Dies bewerkstelligen wir mit

java HelloWorld

Man sollte darauf achten, dass hier keine Dateiendung angegeben werden darf. Als Ausgabe solltet ihr nur ein kurzes “HelloWorld” auf der Konsole / Eingabeaufforderung sehen.

Ich hoffe, ihr hattet viel Spaß mit dem ersten kleinen Java-Tutorial und freut euch auf die kommenden!

Davon werde ich natürlich auch Gebrauch machen und hier am 24. März 2009 mit dem offiziellen Beginn des Kurses die ersten Aufgaben, Mitschriften und Lösungen posten. Diese werden dann unter den Java Tutorials zu finden sein. Auch können diese Unterlagen auf der Seite der Freitagsrunde unter der Rubrik Javakurs 2009 eingesehen werden. Dort findet man sorgar auch Videomitschnitte der Vorträge.

Leider gibt der Firefox beim Besuch der Seite der Freitagsrunde eine Fehlermeldung aus:

“Fehlercode: sec_error_unknown_issuer”

Die Seiten der Freitagsrunde sind vertrauenswürdig und können ohne Bedenken auf die Ausnahmeliste gesetzt werden, damit beim nächsten Besuch diese Meldung nicht mehr erscheint.

Dabei geht man folgendermaßen vor:

1. Seite der Freitagsrunde aufrufen
2. Auf der Fehlerseite diesen Link klicken
   

   “Oder Sie können eine Ausnahme hinzufügen…”

3. Auf den Button klicken:
   

   “Ausnahme hinzufügen…”

4. Es erscheint ein neues Fenster. Hier klickt man nun auf
   

   “Zertifikat herunterladen”

5. Sich vergewissern, dass ein Haken gesetzt ist bei
   

   “Diese Ausnahme dauerhaft speichern”

6. Jetzt folgt ein letzter Klick auf den Button
   

   “Sicherheit-Ausnahmeregel bestätigen”

7. Die gewünschte Seite wird neu geladen und der Inhalt wird sichtbar