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

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.

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