Einführung
Nachdem wir im vorhergehenden Workshop (Java-Einführung) die ersten praktischen Erfahrungen mit Java gemacht haben, wollen wir uns jetzt ein bisschen mit der Theorie zu Java befassen.

Datentypen
Bevor man mit irgendetwas anderem anfängt, sollte man sich um die Datentypen in Java bekümmern, schließlich steht die Definition der Variablen meist am Anfang jedes Quellcodes. Da, wie du schon wissen solltest, Java eine sehr auf Sicherheit getrimmte Sprache ist, nimmt es Java auch mit dem Datentypen recht ernst.
Es macht jetzt jedoch an dieser Stelle - meines Erachtens - keinen Sinn alle Datentypen inklusive ihres Wertebereichs und des Platzbedarfs auf zu listen; man braucht für den Hausgebrauch nur die wenigsten Datentypen, weshalb ich auch nur die wichtigsten behandeln werde.
Fangen wir erst einmal mit Zahlen an: Da gibt es zum einen short für die "kleinen Zahlen" (bis ± 32.768), wenn die Zahlen etwas größer sein müssen, dann gibt es int (bis ± 2.147.483.648). Wenn auch das noch nicht ausreichen sollte bietet sich long an (für wirklich große Zahlen bis ± 92.233.772.036.854.775.807). Der Speicherbedarf verdoppelt sich dabei immer (von 8 auf 16 auf 32 und schließlich auf 64 Bit). Bis jetzt waren unsere Datentypen nur für Ganzzahlen geeignet. Für Fließkommazahlen (Kommazahlen) gibt es float und double. float benötigt 32 und double 64 Bit.
Datentypen gibt es selbstverständlich nicht nur für Zahlen, sondern auch für Buchstaben. Wenn in der Variable nur ein Buchstabe gespeichert werden soll, dann bietet sich char an. Dort kann ein Zeichen für 16 Bit gespeichert werden. Jeder der sich auch nur ein wenig mit Programmierung auskennt wird noch eine Datentypenart vermissen: Zeichenketten-Datentypen in denen Wörter und Sätze (jedenfalls mehr als ein Zeichen) gespeichert werden können. Diesen Datentyp wird man in Java vergeblich suchen. Doch keine Angst, man kann natürlich auch Zeichenketten speichern. Für diese Zwecke gibt es String, das ist jedoch kein gewöhnlicher Datentyp, sondern eine Klasse mit Methoden. Das heißt, die Entwickler von Java waren so freundlich uns mehr als einen Datentypen zur Verfügung zu stellen, sie haben uns gleich ein Objekt geliefert, mit dem man den Speicherinhalt auch gleich weiterverarbeiten kann. Ganz schön clever, schließlich wird dieses Objekt auch am häufigsten verwendet.

Variablen
Jetzt kennen wir die wichtigsten Datentypen in Java, diese wollen wir nun nützlich einsetzen. Das geht natürlich am besten im Zusammenhang mit Variablen. Für alle die mit dem Begriff Variable noch nichts anfangen können ganz kurz: Eine Variable ist der Name für eine Speicherstelle im Hauptspeicher; sie macht es dem Programmierer einfach auf den Inhalt zuzugreifen in dem einfach nur der Variablenname aufgerufen werden muss. Der Inhalt der Speicherstelle kann sich ändern, der Variablenname bleibt immer gleich.
Bevor man die Variablen benutzen kann muss man sie definieren, damit Java schon einmal für die Variable die benötigte Speicherstelle zu reservieren, die Länge richtet sich nach dem Platzbedarf des Datentypen. Aus diesem Grund steht man vor dem Problem, ob man einen Datentyp verwenden soll, der einen möglichst großen Wertebereich hat, oder den Datentyp der am wenigsten Speicher verbraucht.
Variablen werden allgemein so definiert: erst den Datentyp, dann den Variablennamen (also z.B. int a; usw.).
Da muss man jetzt natürlich mit String aufpassen! Wer sehr aufmerksam den vorherigen Abschnitt gelesen hat, der hat gemerkt, dass ich alle Datentypen kleingeschrieben habe (so müssen sie dann auch in der Definition geschrieben werden), bis auf String. Das habe ich groß geschrieben, was kein Tippfehler ist, sondern Absicht.
Wir erinnern uns: String ist gar kein gewöhnlicher Datentyp, sondern eine Klasse mit Methoden! Aus diesem Grund wird String groß geschrieben (also String b;).
Ich möchte an dieser Stelle noch etwas zur Wahl des Bezeichners (Variablennamens) loswerden: 1. dieser unterliegt Konventionen, so muss er mit einem Buchstaben beginnen und darüber hinaus nur aus Buchstaben, Ziffern und dem Unterstrich ( _ ) enthalten. 2. Java beachtet die Groß- und Kleinschreibung ganz genau: name, Name oder NAME sind unterschiedliche Bezeichner! Dadurch entstehen Fehler (auch das Semikolon nicht vergessen).
Noch ein weiterer Trick für die Definition: Werden mehrere Variablen mit dem gleichen Datentypen benötigt, kann man sie auf einmal definieren und zwar z.B. so int a, b; (also die Aufzählung durch Kommata getrennt).
Bis jetzt haben wir die Variablen nur definiert, doch einfach so bringen sie mir gar nichts. Man muss den Variablen etwas zuweisen und das geht so: a = 7; bei Zahlen oder b = 'Wort'; für Zeichenketten. Zeichenketten werden also in Hochkommata (lässt sich mit [Shift] + [#] machen) eingeschlossen. Achtung bei Fließkommazahlen: Kein Dezimal-Komma sondern ein Dezimal-Punkt. Ansonsten ist mit "unerklärlichen" Fehlermeldungen zu rechnen.
Wie in der Einführung zu Java schon erwähnt, hat Java seine Ursprünge in der Programmiersprache C++. Von dieser hat er auch folgende Form der Zuweisung geerbt: intZahl += 5
Das ist die Abkürzung für: intZahl = intZahl + 5. So lässt sich einige Arbeit bei der Zuweisung sparen.

Allgemeine Hinweise
So bevor ich nun mit den komplexeren Programmiergrundlagen fortfahre, möchte ich noch ein paar allgemeine Hinweise zur Programmierung mit Java loswerden.
Wenn man Fehler leichter finden will, Übersicht in sein Programm bringen will oder nicht alleine an einem Projekt arbeitet, dann empfiehlt es sich den Quelltext einzurücken. Bei if-Bedingungsabfragen, Methoden und Klassen bietet sich das Einrücken zwingend an. JCreator macht es bei diesen Bestandteilen automatisch (wenn man diesen Editor denn verwendet).
Wenn eine Anweisung, z.B. eine if-Bedingungsabfrage oder eine Methode, mehrere Zeilen Quelltext umfasst sind diese in geschweifte Klammern ({ })zu schreiben. Das sieht dann z.B. so aus:

Ich kann gar nicht oft genug betonen, wie wichtig in Java die korrekte Schreibweise ist! Variablen oder Schlüsselwörter zum Beispiel, müssen immer exakt - das beinhaltet auch die Groß- und Kleinschreibung - so wie sie vereinbart sind geschrieben werden. Auch gerne wird das Semikolon vergessen, was hin un wieder zu kompliziert zu lokalisierenden Fehlern führt.

Variablenumwandlung
Nach ein paar Tipps zur Auflockerung nun weiter im Programm. Nicht immer ist der Datentyp für die Situation passend: Wenn man mit einer Benutzereingabe (meist im String-Format) rechnen möchte (geht nur mit numerischen Datentypen) steht man vor einem Problem. Man muss die Eingabe irgendwie in das numerische Format umwandeln. Wer mal mit Visual Basic gearbeitet hat, der wird sich an den "tollen" Datentyp Variant erinnern, der alles automatisch umwandelt (dabei aber dummerweise Speicherplatz verschwendet). Dies gibt es in Java NICHT!
In Java muss der Datentyp in den man umwandeln will bekannt sein:
numInt = Integer.parseInt (strEing);

Hier wird eine Benutzereingabe strEing in einen numerischen Wert umgewandelt, der der Variable numInt zugewiesen wird. Die Umwandlung wird mit dem Methodenteil parse[...] (bei uns parseInt) durchgeführt, der zum Objekt des Datentyps gehört.
Konkret heißt das: numInt ist eine Integer-Variable, also ist das Datentypobjekt Integer., dann der Methodenteil parse und für Integer Int und in Klammern die Variable die umgewandelt werden soll.
Diese Umwandlung funktioniert nicht nur ins Integer-Format, sondern auch für alle anderen einfachen Datentypen (byte, short, int, long, float und double).
Will man ASCII-Zeichen auf dem Bildschirm ausgeben, so muss man den ASCII-Wert (also die Zahl aus der ASCII-Tabelle) in ein ASCII-Zeichen (also a,b oder c) umwandeln. Dieser Vorgang wird Typecast genannt und sieht so aus: (char)zeichen

Kontrollstrukturen
Bis jetzt wurde davon ausgegangen, dass ein Programm einfach nacheinander ausgeführt wird. Das ist jedoch nicht immer sinnvoll. Oft ist es notwendig, dass das Programm auf Situationen reagiert. Wenn der Benutzer folgendes tut, dann soll das Programm folgendes tun (vielleicht auch mehrfach).
Genau dafür wurden Kontrollstrukturen geschaffen. Diese kann man in zwei verschiedene Techniken unterteilen. Zum einen die Auswahl, d.h. wenn folgendes eintritt, dann tue dies (oder das). Zum anderen die Wiederholung, d.h. solange die Situation besteht (oder nicht besteht) tue dies.

Auswahl
Wie ich im obigen Abschnitt erwähnt habe, werden mit Hilfe der Auswahl in Abhängigkeit von einer Bedingung Anweisungen ausgeführt oder weggelassen. Das Programm kann also selbstständig auf Bedingungen reagieren.
Solche Bedingungen bestehen meist aus Vergleichen mit den Operatoren >, <, >= (größer gleich), <= (kleiner gleich), == (gleich) und != (ungleich). Also z.B. Ist Uhrzeit == 12 dann rufe zu Mittag.
Bei dem Gleichheitsoperator ist darauf zu achten, dass man zwei Gleichheitszeichen hintereinander schreibt; manche andere Programmiersprache erlaubt den Vergleich mit Gleichheitszeichen, Java ist da aber sehr genau und reserviert das einzeln stehende Gleichheitszeichen lediglich für die Zuweisung.

Auswahl mit if
In Java wird eine Auswahl mit if so geschrieben:
if (Bedingung) Anweisung;

Wie ich oben bei den Tipps schon vorweg genommen habe, werden mehrere Anweisungen in geschweifte Klammern eingeschlossen.
Wir haben hier die allgemeine Anweisung für eine sogenannte einseitige Auswahlstruktur, d.h. es wird nur dann etwas getan, wenn die Bedingung stimmt.
Im Gegensatz dazu wird bei der sogenannten zweiseitigen Auswahlstruktur auch dann noch was getan, wenn die Bedingung nicht stimmt. Also z.B. beim Geldautomaten: Ist Kontenstand > 0 dann Abheben erlaubt, sonst Meldung über zu niedrigen Kontenstand ausgeben. Die zweiseitige Auswahlstruktur sieht in Java so aus:
if (Bedingung) Anweisung1; else Anweisung2;

Wie man sieht, wird der sonst-Fall mit else eingeleitet. Ich möchte noch auf gerne gemachte Fehler hinweisen:
Hinter if (Bedingung) steht nie ein Semikolon! Wenn man also mehrzeilige Anweisungsblöcke hat, dann kommen nur hinter die Anweisungszeilen Semikolons!
Anweisungsblöcke werden nur dann als Block ausgeführt, wenn man diese in geschweifte Klammern schreibt. Ansonsten wird nur die erste Zeile des Anweisungsblocks von der Bedingung abhängig gemacht und die anderen werden immer ausgeführt!

Bedingungsverknüpfung
An dieser Stelle möchte ich nun noch was zu der Bedingung sagen: Bisher haben wir nur eine Bedingung gehabt. Manchmal sind aber mehrere Bedingungen zu erfüllen, bevor die Auswahl stattfinden soll. Wenn wir wieder auf unser vorletztes Beispiel zurückkommen: Ist (Uhrzeit == 12 && Wochentag == Sontag) dann rufe zum Sonntagsbraten.
Hier siehst du auch schon die richtigen boolschen Operatoren für die UND-Verknüpfung. Darüber hinaus gibt es noch den ODER-Operator || ([Alt Gr] + [<]). Der Unterschied ist, dass beim UND-Operator beide Bedingungen gleichzeitig erfüllt sein müssen. Beim ODER-Operator reicht es wenn nur eine der Bedingungen erfüllt ist.

Mehrseitige Auswahl
Es gibt zwei Formen der mehrseitigen Auswahl. Die eine ist die mehrseitige Auswahl mit switch und die andere if mit else if.
Die erste Form mit switch ist sehr speziell, da die Bedingungsabfrage darauf beruht, dass sich die einzelnen Fälle nur in einem Punkt unterscheiden und sich alle auf einen Ausdruck beziehen der bei allen Fällen gleich ist. Das hört sich kompliziert an, ist jedoch einfach, wenn man sieht was gemeint ist. Beispiel Noten in der Schule: Bei allen ist der Ausdruck Note gleich, die einzelnen Fälle unterscheiden sich einzig und allein darin, dass der Wert der Note (1,2,3,4,5,6) unterschiedlich ist.

Mehrseitige Auswahl mit switch ... case
Im Gegensatz zu Select...Case in Visual Basic sind bei switch...case nur abzählbare Werte als Selektor (Fall) erlaubt, d.h. keine Datentypen wie double und float. Allgemein ist eine mehrseitige Auswahl mit switch...case so aufgebaut:

Wenn man sich die Quellcodezeilen also einzeln ansieht, dann lässt sich folgendes sagen: Man "nummeriert" die einzelnen Fälle nach folgendem Muster durch: case und dann der Wert z.B. Note 1, dann ist es wichtig, dass man den Doppelpunkt nicht vergisst. Dann kommt die eigentliche Anweisung, die mit einem Semikolon abgeschlossen wird. Wenn man Anweisungsblöcke mit mehreren Zeilen hat, dann sind diese in geschweifte Klammern zu stellen. Gerne vergessen wird dann das break-Kommando gefolgt von einem weiteren Semikolon. Lässt man dieses break-Kommando weg, dann wird der nächste Fall ebenfalls überprüft und möglicherweise ausgeführt (wenn man einen Zahlenraum angibt). Der default-Fall kann eigentlich weggelassen werden, er muss nur eintreten, wenn z.B. eine Meldung erscheinen soll wenn kein anderer Fall eingetreten ist. Hier ist kein break notwendig, da es immer der letzte Fall ist.
Wie schon bei if() muss darauf geachtet werden, dass hinter switch(Ausdruck) kein Semikolon zu stehen hat!

Mehrseitige Auswahl mit if()
Die Auswahlstruktur hatten wir schon einmal bei der ein- und zweiseitigen Auswahl. Mit dem Schlüsselwort else if kann man auch noch eine mehrseitige Auswahlstruktur daraus machen. Man unterscheidet einfach auch noch im if bzw. else-Fall. Also z.B.:

Wenn die erste Bedingung nicht erfüllt wird, dann schauen wir, ob die zweite Bedingung erfüllt wird, sonst führen wir die dritte Anweisung aus.
Bei dieser Möglichkeit besteht jedoch recht leicht die Gefahr, dass es sehr unübersichtlich mit den Fällen wird. Jedoch hat diese Methode den Vorteil, dass wir die freie Auswahl an Datentypen haben. Außerdem lässt sich so auf einfache Weise schnell mal eine if()-Auswahlstruktur erweitern, ohne dass man den Rest neu entwerfen müsste. Hierbei ist übersichtliche Gestaltung das A und O.