Offizielle Javaseite bei Oracle: Java Startseite
Hier kann man Klassen speziell für Desktop laden.

Geschlossenes Java - Forum in ehemaligem Peter Herzog's spotlight.de.

Fachliteratur (Tutorial, Dokumentation) nur online verfügbar? Kein Problem. Web Loader, von Oleg Chernavin dessen FreeWare Version man von zdnet.de downloaden kann, speichert man Abbild interessanter Seiten (einschließlich Bilder) an eigener Festplatte um sie ohne laufende Onlinekosten lesen zu können.
Für XP, Vista usw. gibt es HTTrack von HTTrack Seite (nicht von mir getestet).

Buch zum Downloaden:
Das Java - Buch von Guido Krüger.

Wo bekommt man Java?

DOS Box ¤
Ist eigentlich nur ein DOS Fenster in Windows. In Verzeichnis C:\WINDOWS befindet sich Datei COMMAND.COM. Wenn man sie, oder eine Verknüpfung zu ihr mit rechten Maustaste anklickt, und dann auf Eigenschaften klickt, dann kann man unter Bildschirm bzw. Optionen wählen zwischen Vollbild oder Fenster (DOS - Box). In WinXP findet man DOS-Box unter Start/Programme/Zubehör/Eingabeaufforderung. Die Datei versteckt sich unter \Windows\system32\cmd.exe.
Man kann gleichzeitig mehrere DOS - Fenster auf seinem Bildschirm öffnen.

Environment - Umgebungsvariablen ¤
Etwa 0,5kB großer Speicher wo einige für DOS Programme wichtige Variablen abgespeichert sind. Jedes DOS Fenster beinhaltet eigenes Environment, eine Kopie der Eingaben die Autoexec.bat und CONFIG.SYS  erstellt haben.

set ¤
Befehl set zeigt Inhalt des Environments an. Set mit Variablenname (z.B. set path=) löscht Inhalt der Variablen. set Variablenname=Variableninhalt, Variable wird neu gesetzt. Man beachte die Syntax (keine Leerzeichen)! Ob die Einträge groß- oder klein geschrieben sind, ist allerdings egal.

Variable path ¤
Command.com sucht ausführbaren Dateien zuerst in aktuellem Verzeichnis dann der Reihe nach in Verzeichnissen die in "path" eingetragen sind. Einzelne Einträge müssen ohne Leerzeichen erfolgen, getrennt sind sie durch Zeichen ; . Wenn keine Erweiterung des Programmnamens eingegeben wird, versucht es Command zuerst mit .com, dann mit .exe und .bat. Wenn man in DOS-Box path eingibt, Inhalt der path Variablen wird ausgegeben.

Batchdatei - Stapelverarbeitungsdatei ¤
Eine reine Textdatei mit Erweiterung  .bat, in der DOS Befehle so stehen wie man sie in DOS - Box eingeben müßte. Eine Zeile - ein Befehl! Es kann somit ein ganzer Stapel Befehle geben. Im Register Eigenschaften/Programm/Stapelverarbetungsdatei eines DOS-Programms kann man Namen der Batchdatei eingeben die bei Start der DOS - Box abgearbeitet werden soll. Somit spart man sich viel Tipparbeit bei konfigurieren der DOS - Box, und man kann somit leicht verschiedene Konfigurationen verwalten (beispielsweise verschiedene Einträge für path in verschiedenen DOS - Boxen).

Einige Befehle der Batch - Datei (Die man für SDK brauchen kann)
 

rem	Bemerkung
@  Echo	Echo (Ausgabe des Befehls am Bildschirm ) in dieser Zeile unterdrücken.
echo off	Echo generell ausschalten.
echo on	Echo generell einschalten.
:name	Name einer Sprungmarke
goto name	Springe zu Sprungmarke name.

Direkteingabe "echo" - Befehls in Dos-Box zeigt ob echo on oder off ist. Eingabe "echo off" in Dos-Box bewirkt, daß Ausgabe von Prompt unterdrückt wird. Somit ist "echo" - Befehl eigentlich nur in Verbindung mit einer Batch-Datei nützlich. Befehl "echo off" in einer Batchdatei wird in dem Moment aufgehoben wenn Batchdatei abgearbeitet ist.

Weitere nützliche DOS Befehle

Laufwerksbuchstabe gefolgt von Doppelpunkt (z.B. c:) ¤
Wechselt zu gegebenem Laufwerk.

cd  (change directory) ¤
Ändert Verzeichnis (Ordner). Möglich ist Eingabe vollen Pfadnamens oder Teils des Namens ab aktuellem Verzeichnis in Richtung Unterverzeichnis.
cd.. (cd Punkt, Punkt) springt um eine Ebene höher.
cd\  (cd Backslash) springt von überall zu dem höchstem Verzeichnis (Stammverzeichnis).

Prompt ¤
Ändert Aussehen der Eingabeanforderung. Übliche Einstellung ist prompt $p$g, d.h. aktuelles Verzeichnis an aktuellem Laufwerk gefolgt von einem ">".

DOS Editor ¤
DOS Fenster beinhaltet einen primitiven Zeileneditor, Funktionalität kann bei verschiedenen DOS Varianten etwas variieren. Allgemein gilt: Nach Betätigung der Taste Return wird Inhalt der Befehlszeile in einem Zeichenpuffer abgespeichert und Befehl wird ausgeführt.
Nach Betätigung Taste F5 wird Inhalt der Befehlszeile lediglich im Zeichenpuffer abgespeichert, Befehl wird jedoch nicht ausgeführt.
F1: Inhalt des Zeichenpuffers wird Zeichen für Zeichen ausgegeben.
F2 gefolgt von einem Zeichen: Inhalt des Zeichenpuffers wir bis zu diesem Zeichen ausgegeben, das Zeichen jedoch nicht.
F3: Rest des Zeichenpuffers wird ausgegeben. (Sehr nützlich zum Wiederholen eines vorher eingetippten Befehls!)
F4: Überspringt bis zu einem angegebenen Zeichen alle Zeichen in Zeichenpuffer.
Entf: Überspringt ein Zeichen in Zeichenpuffer.
Einfg: Schaltet Einfügungsmodus ein und aus.
ESC: Hebt die gegenwärtige Befehlseingabe aus, ohne Zeichenspeicher zu verändern (vorherige Eingabe ist also immer noch im Zeichenpuffer).
Taste Cursor links oder Backspace: Letztes Zeichen  der Eingabezeile wird gelöscht, bleibt jedoch in Zeichenpuffer enthalten.

Wenn man mehrere DOS - Fenster öffnet und DOS Editor geschickt ausnutzt kommt man auch ohne einer Entwicklungsumgebung ganz flott voran.

Installation

Hat man alles richtig gemacht, bei Klick an die Verknüpfung erscheint ein DOS - Fenster mit aktuellem Verzeichnis E:\java\programme. Nach Eingabe java oder javac muß eine Liste Optionen erscheinen. Falls eine Fehlermeldung "Datei nicht gefunden" erscheint, dann stimmt mit PATH etwas nicht, man hat irgendwo einen Fehler gemacht.

Jar in Windows mit Doppelklick starten
Hat man gelernt wie man executable jar Datei erstellt und von DOS-Box startet, dann kann man Windows so einrichten, daß man jar Datei per Doppelklick startet. Jar Datei mit java.exe oder javaw.exe (für Lauf ohne DOS-Fenster) verbinden. Klick mit rechter Maustaste auf jar Datei, Öffnen mit..., Button Andere. Java oder javaw finden und bestätigen. Bei XP: Öffnen/Programm aus einer Liste wählen. Dann in Dateiexplorer: Ansicht, Ordneroptionen..., Karte Dateitypen des Assistenten Ordneroptionen anwählen. Datei JAR finden, anklicken und Button Bearbeiten klicken. Im Fenster Vorgänge open klicken und Button Bearbeiten klicken. Das Fenster Anwendung für diesen Vorgang so bearbeiten, daß hinterm Dateinamen -jar "%1" steht. Bei XP, falls nötig: Extras/Ordneroptionen/Dateitypen. JAR. Dateityp bearbeiten. Aktionen: open. Bearbeiten: "Laufwerksbuchstabe:\Programme\Java\jre6\bin\javaw.exe" -jar "%1" %* (Wenn z. B. JRE6 -Java6- im Standardverzeichnis installiert ist.)
Hat man .jar mit falschem Programm verbunden, man klicke bei gedrückter Umschalttaste mit rechter Maustaste auf die .jar Datei. Menüpunkt "Öffnen mit..." erscheint wieder.

Wenn alles in Ordnung ist, dann kann man mit einem ASCII - Texteditor (dem gleichen mit dem man die Batch-Datei erstellt hat) sein erstes Programmversuch starten.

 Quelltextdatei (mit Extension .java ) abspeichern. Dann Befehl javac Dateiname eingeben (Dateiname samt Extension .java, Groß- und Kleinschreibung des Dateinamens beachten) und Quelltext compilieren lassen. In dem aktuellem Verzeichnis entsteht eine Datei Dateiname.class. Diese Datei startet man mit dem Befehl java Dateiname (Eingabe ohne Extension, Extension .class wird vorausgesetzt, Groß- und Kleinschreibung des Dateinames beachten).

 Falls man mehrere Programme mit SDK erstellt, dann ist es empfehlenswert für jedes Programm eigenes Unterverzeichnis im Verzeichnis EigeneProgramme einzurichten (zwischen Unterverzeichnissen wechselt man mit Befehl cd).

Dateiname muß den gleichen Namen haben wie class heißt. Z.B. class HalloWelt speichert man in HalloWelt.java.

Für Test noch das allbekannte "Hallo Welt" Beispiel etwas aufgemöbelt:

//*************************************************************************************************************************
import java.awt.*;
import java.awt.event.*;

class HalloWelt extends WindowAdapter
        {
        Frame fenster;
        TextField txf,t1;
        String text = new String("+++Hallo Welt, ein neuer Java Experte ist da!+++");


        HalloWelt()
                {
                fenster = new Frame("Hallo Welt");
                fenster.add(t1 = new TextField());      // untem txf verstecktes TF um Fokus von txf abzuweisen
                fenster.add(txf = new TextField(40));
                fenster.addWindowListener(this);
                fenster.pack();
                fenster.show();
                fenster.setResizable(false);
                System.out.println("Programm wird gestartet.");
                laufBand(text);
                }

        void laufBand(String s)
                {
                StringBuffer stbf = new StringBuffer(s);
                stbf.insert(0,"                                                        ");
                while(true)
                        {
                        txf.setText(stbf.toString());
                        txf.transferFocus();
                        try {Thread.sleep(200);}
                        catch(InterruptedException e) {}
                        Thread.yield();     // wartende Ereignisse abarbeiten
                        stbf.append(stbf.charAt(0));
                        stbf.deleteCharAt(0);  // restlicher Text wird automatisch nach links verschoben
                        }
                }

        public void windowClosing(WindowEvent e)
                {
                System.out.println("Programm erfolgreich beendet.");
                System.exit(0);
                }

        public static void main(String[] args)
                {
                HalloWelt hallo = new HalloWelt();
                }
        }
//*************************************************************************************************************************

Objektorientiertes Programmieren ohne Brimborium und Heiligenschein

Mit Einführung lokalen Variablen in den Prozeduren und Trennung des Prozedur-Quelltexts vom Hautprogramm sang die Gefahr eines Programmierfehlers, und es war möglich ein Programm wirklich zu strukturieren (z.B. Q - Basic). Dabei wurden Methoden der Parameterübergabe ( by value oder by reference) eingeführt, sowie auch Möglichkeit einer Wertrückgabe. (Eine Prozedur mit Wertrückgabe hieß Funktion.)
Es hat sich herausgestellt, daß es vorteilhaft wäre wenn einige Variablen zwischen einzelnen Aufrufen der Prozedur ihren Wert behalten könnten. Deshalb wurde ein Typ der Variablen namens static eingeführt.

Nun, mit immer umfangreicheren Programmen stellte sich heraus, daß man Prozeduren bräuchte die zwar fast identisch sind, jedoch verschiedene Parameter benötigen: Man stelle sich vor ein Programm für einen Tank- und Raststättebesitzer, der sich entscheiden will, ob er bei gegebenem Einkaufspreis und marktgerechten Endpreisen auf gegebener Ware überhaupt etwas verdienen kann. Dazu braucht man Berechnung der Endpreise mittels Aufaddieren indirekter Steuer zur Einkaufspreis. Bei jeder Ware bräuchte man der Prozedur den Einkaufspreis übergeben, Prozentrechnung ist immer gleich, was sich ändert sind die indirekten Steuer und Abgaben für bestimmte Warengruppen ( USt. voll, USt. gemindert, Mineralölsteuer. Ökosteuer, Schaumweinsteuer, Teesteuer, Kafeesteuer, Tabaksteuer, Leuchtmittelsteuer, Ausschanksteuer, Bestechungsgelder, usw.). Ein Satz "static" Variablen hilft da nicht weiter, weil in der Prozedur jede static - Variable nur einen bestimmten Wert haben kann. Verschiedene Warengruppen brauchen jedoch für indirekte Steuern verschiedene Werte. Was man in solch einfachem Fall mit geschickter Programmierung noch umgehen kann stellt sich in wirklich umfangreichen wissenschaftlichen Programmen als äußerst hinderlich aus.

Ausweg aus der Misere: Eine simple wie geniale Lösung. Unterprogramme werden nicht direkt ausgeführt, sondern es wird je nach Bedarf eine Kopie (Instanz) des Unterprogramms samt aller lokalen Variablen erstellt. Einsprungsadressen der Kopien werden von Compiler automatisch ermittelt und in Variablen gespeichert. Mittels dieser Variablen kann man dann die Kopien ansprechen. Also, um bei dem obigen Beispiel zu bleiben, von einer Prozedur namens IndirekteSteuer wird  beispielsweise als reifen = neue IndirekteSteuer eine Instanz gebildet, und Wert für USt wird mit reifen.ust = 16 eingetragen. Das geniale an dieser Technik ist, daß man so nicht nur mir einzelnen Prozeduren verfahren kann, sondern mit ganzen Programmen die seinerseits mehrere Prozeduren beinhalten, und somit erheblich mehr als eine einfache Prozedur leisten können.

Man nenne diese Programme Klassen, ihre Instanzen Objekte, alle lokale Variablen in ihnen lasse man grundsätzlich static sein und nenne sie Eigenschaften, lokale Prozeduren nenne man Methoden, Variablen mit Einsprungsadressen der Instanzen nenne man Ojektvariable, und eine objektorientierte Programmiersprache ist geboren.

Dazu hat es sich noch als praktisch erwiesen keine Prozeduren, sondern nur Funktionen zu benutzen, d.h. jedes Unterprogramm liefert irgendeinen Wert zurück, und dieser Wert muß in Deklaration der Funktion spezifiziert werden. Es kann auch void ("leer") spezifiziert werden, wenn man keinen Rückgabewert programmiert hat (Funktion wird dadurch zu Prozedur).
Die nun frei gewordene Bezeichnung static kann man für die Variablen und Methoden benutzen die nur einmal im Speicher vorhanden sein sollen (von diesen werden keine Instanzen gebildet) und an die man zugreifen kann ohne, daß man eine Instanz gebildet hat, sozusagen "instanzlose" globale Variablen und Methoden. Wenn diese Variablen und Methoden instanzlos sind, dann kann ja auch die "Mutterklasse" in irgendwelche Bibliothek abgelegt werden, und die Methode wird nur im Bedarfsfall zugeladen, nachdem man die Methode über Name der Klasse adressiert hat. Z.B. Thread.sleep(). Eine statische Variable kann aber auch ein Objekt beinhalten wie in System.out. Da wird temporär eine Instanz von Ausgabestrom gebildet und derer Methode println() ausgeführt - ohne daß es sich der Programmierer um jeweilige Details kümmern muß. (Siehe obiges Programmbeispiel, in Abschnitt SDK Installation.)

Variablendeklaration
Schon in der allerersten Programmiersprache, dem Assembler, mußte man gelegentlich eingeben ob ein Wert als Byte, Word, oder Doubleword gemeint ist. In GW-Basic und anderen Sprachen für Anfänger ( z.B. Java-Script) muß man nichts eingeben, Compiler wählt passende Speichergröße aus und generiert Variable automatisch. Nun, man stelle sich vor, in einem Programm mit einigen hundert globalen Variablen verschreibt man sich in Hitze des Gefechts in irgendwelcher Prozedur, und beispielsweise anstatt brote=x schreibt man brite=x. Compiler generiert stillschweigend eine neue Variable "brite" und das arme Schwein von Programmierer sucht wochenlang warum sein Programm ab und zu falsche Ergebnisse liefert. Deshalb wurde Zwang zu Deklaration der Variablen eingeführt, eine Variable muß, bevor sie zum erstenmal benutzt wird, zwingend zuerst deklariert werden. Sollte man irrtümlich eine Variable eintippen, die vorher nicht deklariert wurde, Compiler schlägt Alarm. (Außerdem arbeitet mancher Compiler auch schneller, wenn gleich am Anfang Platzbedarf für Variablen ermittelt wird.)
Es müßte dann beispielsweise heißen:
IndirekteSteuer reifen
     .
     .
     .
reifen = neue IndirekteSteuer

Konstruktoren und Destruktoren
Es ist vorteilhaft gleich bei Erstellen einer Instanz gewisse Dinge zu tun, beispielsweise bestimmte Werte gleich zu übergeben. Deshalb wird zur Erstellung einer Instanz eine spezielle Funktion der Klasse gerufen die man Konstruktor nennt. Bei Löschung einer Instanz wird eine Funktion namens Destruktor gerufen, die beispielsweise besetzen Speicher wieder freigibt.

Wenn man das nützlichste von allen objektorientierten Sprachen nimmt, einfache Syntax einführt, Speichermanagemet automatisch macht ( ohne Destruktoren), defaultmäßige Konstruktore einführt, so daß man eigene Konstruktore nur im Bedarfsfall programmieren muß - da hat man Java.

Geheimnis der virtuellen Maschine