Java-Fieber

Das 5. Kapitel hatte für mich auch erstmal nur wenig neues zu bieten: Entscheidungsstrukturen.

Da gute alte "if" und sein Freund das "else", und später das "switch-case", beide in einer Syntax, die ich für Standart halte (diese sehen zB. in PHP und C++ genauso aus):

if(Bedingung) {
Anweisung;
}
else {
alternative Anweisung;
}

und

switch(Bedingung){

case ersterFall:
Anweisung1;
break;

case zweiterFall:
Anweisung2;
break;

default:
defaultAnweisung;
break;

}

Allerdings sind hier im Detail ein paar "Leckereien" gewesen, über die ich beim nächsten Mal schreibe, nämlich der Unterschied zwischen:

if(password=="swordfish"){
}

und

if(password.equals("swordfish")){
}

- dies soll sich nämlich extrem unterscheiden! Also muss ich das nochmal genauer ausprobieren. Und ich werde die Vergleichs- und logischen Operatoren auflisten, der Vollständigkeit halber.

Wissen:
Mit "if-else" kann man ein- oder zweiseitige Entscheidungen treffen, mit "switch-case" kann man sich vielseitig entscheiden. Natürlich kann man entsprechende Entscheidungsstrukturen dann auch verschachteln, so dass man "wenn Eingabe > 5, Entscheide, ob Eingabe >10" und ähnliches konstruieren kann - schliesslich sind die Anweisungen innerhalb einer Entscheidungsstruktur ja ganz normale Anweisungen!

So, ich habe die zweite Hälfte des 4. Kapitels durch... und bin ein bisschen enttäuscht. Es kamen nicht wirklich Frames dran, sondern es wurde nur ein Frame in einem Beispiel-Listing geöffnet, aber nicht weiter erklärt, sondern lediglich als Beispiel für Refernztypen benutzt. Ausserdem wurde kurz umrissen, wie man eine Instanz einer Klasse erzeugt:

import javax.swing.JFrame;

public class ShowAFrame
{
public static void main(String args[])
{
JFrame myFrame = new JFrame();
String myTitle = "Hallo Welt - Frame";

myFrame.setTitle(myTitle);
myFrame.setSize(300, 400);
myFrame.setDefaultCloseOperation
(JFrame.EXIT_ON_CLOSE);
myFrame.setVisible(true);
}
}

Das war nicht so wirklich spannend. Aber ich will alles von Anfang bis Ende durcharbeiten und hier berichten, also auch eher langweilige Passagen. Trotzdem hab ich noch ein paar Kleinigkeiten gefunden, die ich sonst gerne überspringe, die mir dann aber auch gerne mal fehlen:

Der Modulo-Operator "%" (Das Prozentzeichen)
Gibt den Rest einer (Integer-) Division zurück. Wenn man also rechnet:

17 geteilt durch 3 ergibt 5 Rest 2

int a = 17 / 3;
int b = 17 % 3;

Dann ist a gleich 5 und b ist 2!

Ausserdem wurden die In- und Dekrementoperatoren behandelt: ++a, a++, --a und a--
Dabei wird durch das "++" der Wert der Variablen um 1 erhöht, durch "--" gesenkt. Und ob man's davor oder dahinter schreibt legt fest, zu welchem "Zeitpunkt" der Wert verändert wird - davor schreiben ändert den Wert vor einer etwaigen Berechnung mit der Variablen und vice versa.

Beispiel:

int a = 3;
int b = 5;


a = b++;
// a ist nun 5, aber b ist dann 6!

a = ++b;
// a ist nun 7, da b vor der Zuweisung um 1 erhöht wurde

a = 4 + (--b);
// a ist jetzt 4+(7-1) = 10, und b ist 6

Wissen:
Module-Operator "%" liefert den Rest einer Integer-Division
Wenn man 17/3 rechnen lässt, so erhält man immer 5. Nicht 5,666, weil das Ergebnis im selben Datentyp wie die Operatoren zurückgegeben wird. Wenn man den Bruch erhalten will, muss man vorher klarstellen, dass man mit Kommazahlen rechnen will, zB durch 17.0/3!

Bin gerade durch die erste Hälfte des 4. Kapitels geflizt - Variablen und wie man die deklariert / initialisiert. Nicht unwichtig, aber nur all zu bekannt. Allerdings gab's auch ein paar Dinge, die für mich neu waren oder zumindest interessant:

Lieber immer double als float nehmen, wegen der wesentlich besseren Genauigkeit, 64 Bit bei double zu 32 Bit bei float. Wie mir scheint bin ich alt geworden, denn "damals" hiess es noch, lieber float nehmen, weil der Speicher so begrenzt ist, und nur double nehmen, wenn es notwendig ist. Aber naja. Lieber Nachdenken als Nachbeten ist meine Devise.

Dann gibt's die "Primitiven" oder "atomaren" Variablen, namentlich:
Ganzzahlen: byte, short, int, long (8, 16, 32, 64 Bit)
Dezimalzahlen: float, double (32, 64 Bit)
Zeichen: char (16 Bit)
Logisch: boolean (steht da nicht, ist aber 1 Bit )

Neu, bzw. zu beachten: Bei einem char wird immer mit einfachen Anführungszeichen gearbeitet, beim String mit doppelten: ' -> "

Das auf die Primitiven aufbauende nennt man "Referenztypen", das sind dann zusammengesetzte Variablen, das Paradebeispiel ist der String als Zusammensetzung von chars.


Ganz nebenbei ist in dem Kaptiel eine neue Funktionalität genutzt worden, und zwar "import". Das sieht dann zB so aus:

import static java.lang.System.out;

Und hat den Effekt, dass ich ab da statt

System.out.println("Hallo Welt!");

kurz folgendes verwenden kann:

out.println("Hallo Welt!");

Das spart mir hier nur das "System", aber ich denke, wenn man so richtig tief verschachtelte Kisten hat, dann spart einem das einiges an Tipparbeit (macht mich also schneller) und zum anderen wird der Code bestimmt wesentlich lesbarer (also mach meinen Code besser). Zumindest, solange man es nicht übertreibt


Wissen:
Auch als alter Hase die Basics genau durchlesen, auch wenn das langweilig ist. Man findet oft trotzdem wichtige Infos!
Primitive und Referenztypen - Begriffe merken, um damit angeben zu können!
"import" spart Tipparbeit.


PS: Ich hab schon ein bisschen weitergeblättert, da kommen dann erste Frames! Aber dafür ist's mir heute zu spät.

Eigentlich wollte ich ja heute nix mehr machen... Aber in Kapitel 3 geht es um die Java Grundbausteine, und ENDLICH komme ich zum "Hallo Welt!"-Programm! Auch wenn das Buch eigentlich einen anderen Text vorgibt, ich finde, an diese Tradition muss man sich halten!

class Displayer
{
public static void main(String args[])
{
System.out.println("Hallo Welt!");
}
}

Ist das nicht schön!?


Wissen:
Java-API: Application Programming Interface - eine Codesammlung mit tausenden von Funktionen. Am besten sollte man sich eine entsprechende Referenz-Sammlung zulegen, ich nehme erstmal:
Java 6 API Dokumentation

Oh, noch was: Wenn man nicht neu kompiliert, sind auch die Änderungen noch nicht im ausführbaren Programm, auch wenn man fünf mal ausführen klickt... (d'oh)

PS: Ich muss was finden, um Code vernünftig darzustellen...

Bin heute wieder viel zu früh wachgeworden. Ich glaube langsam wirklich, dass der Begriff Java-Fieber ziemlich zutreffend ist. Ich habe mich heute morgen erstmal durch die Weboberfläche meines neuen Webspaces gearbeitet, ist richtig schön umfangreich. Aber es soll hier ja um Java gehen, und nicht um Werbung für meinen Provider (es sei denn, der würd mich dafür bezahlen ). Aber der Webspace gehört ja irgendwie mit zu diesem Projekt.
Deswegen habe ich auch noch nichts praktisches mit Java gemacht, aber ich werde mich jetzt mit ner gemütlichen Tasse Kaffee auf die Couch lümmeln und das dritte Kapitel lesen. Und vor Sonntag wird das wahrscheinlich eh nicht mehr, weil ich nachher zu nem alten Freund fahre, den ich schon viel zu lange nicht mehr gesehen habe und werde erst am Sonntag irgendwann wieder da sein.