Man lädt zunächst eine Installationsdatei herunter, führt diese ein Mal aus und löscht sie dann wieder. Danach kann ist Java und auf dem Rechner allgemein verfügbar.

- Gehe zur Download-Seite von Oracle und lade den aktuellen JDK herunter. Akzeptiere hierzu die Lizenz-Bedingungen. Speichere die Datei z.B. auf dem Desktop.

1. Führe die Datei als Administrator aus. Damit wird Java installiert.
2. Merke dir wohin dein JAVA installiert wird. Stift und Papier sind hier hilfreich.
3. Gehe nun zu JavaDoc
4. Öffne diese komprimierte zip Datei mit deinem Explorer und kopiere das Verzeichnis doc in dein JAVA-JDK Verzeichnis. Bei mir ist das C:\Program Files\Java\jdk1.8.0_91 das muss aber je nach Windows Version nicht so sein, deshalb sollst du dir ja das Installationsverzeichnis merken.
5. Bitte installiere als letztes den [Java-Editor
6. Lösche die Installationsdateien vom Desktop. Sie wird nicht mehr gebraucht. Wenn du Freunde hast, die an unzugänglichen Stellen des Landes leben (also ohne DSL), dann wirf die Datei nicht weg, sondern gib sie ihnen auf einem USB-Stick!

Programmieren lernt man durch programmieren, aber erst, wenn man einmal genau verstanden hat, was alles passiert. Man muss wissen

• wie die Datei heißt, die man gerade bearbeitet,
• wo die Datei ist,
• wie man den Compiler aufruft, der aus der Datei ein ausführbares Programm macht
• und wie man das ausführbare Programm ausführt.

Am Anfang sollte man keine komplizierten Hilfsmittel verwenden, weil die das Verständnis verschleiern. Also lieber kein Eclipse, NetBeans o.ä. sondern einfach alles aus der DOS-Box heraus! Aber die muss man auch erst mal haben.

Öffne also eine Eingabeaufforderung (Windows) oder Konsole (Linux). Normalerweise ist der aktuelle Aufenthaltsort dann das Home-Verzeichnis des aktuellen Users. Die folgenden Schritte gelten für Windows-User. Wer dazu nicht gehört, weiß wahrscheinlich eh schon, wie man einen Computer bedient.

1. Gehe in das Verzeichnis, wo du dein Programm am Ende haben willst. Tippe also z.B.

   cd Desktop

   wenn es dich nicht stört, dass alles auf dem Schreibtisch rumliegt. Wenn deine Dateien auf den Memory-Stick (mit Laufwerksbuchstabe M) ins Verzeichnis javaprogramme sollen, kannst du tippen

   m:
   cd javaprogramme

2. Um zu sehen, welche Dateien schon da sind, tippe

   dir

3. Starte nun den Editor deiner Wahl, z.B. GVim und gib gleich den Namen der Datei an, die du erzeugen willst. Die Datei wird sich am Ende genau in diesem Verzeichnis hier befinden, von wo du den Editor gestartet hast.

   gvim Test.java

   Beachte, dass hier ausnahmsweise ein Großbuchstabe im Namen erwünscht ist.

4. Schreibe nun das Programm und vergiss nicht, es auch abzuspeichern. Mit Vim macht man das durch Esc : w
   Das Programm könnte folgenden Inhalt haben:

   public class Test{
     public static void main(String[] args){
       System.out.println("Hallo "+args[0]);
     }
   }

Will man aus dem vom Menschen lesbaren Programmtext Test.java ein ausführbares Programm machen, so muss man den Text dem Compiler javac geben. Der erzeugt daraus die Datei Test.class, falls keine Fehler gemacht wurden. Danach sieht man am besten gleich nach, ob die class-Datei auch wirklich da ist.

c:\programme\java\jdk\bin\javac Test.java
dir

Beachte, dass man dem Rechner sagen muss, wo javac ist, weil er es alleine nicht findet. Deshalb ist es bei der Installation so wichtig, einen Pfad anzugeben, an den man sich später noch erinnern kann.

Nun wollen wir das Programm noch ausführen. Das tut der Befehl java, der auf dem gleichen Pfad wie javac liegt, also

c:\programme\java\jdk\bin\java Test Susi

Während der weiteren Entwicklung eines Programms muss man all diese Schritte mehrfach ausführen. Glücklicherweise braucht man dafür jetzt auch in der DOS-Box nur noch die Pfeil-Tasten drücken, um die vorher mühsam getippten Befehle wieder zu bekommen.

Vereinzelt höre ich von Schülern, dass Sie alles so gemacht haben, wie hier beschrieben, dass aber Java die fertig kompilierten .class-Dateien nicht findet. Im Arbeitsverzeichnis befinden sich dann z.B. die Dateien Test.java und Test.class, aber der Befehl

c:\programme\java\jdk\bin\java Test Susi

führt zu einem NoClassDefFoundError.

In diesem Fall ist bei der Installation von Java eine Kleinigkeit schief gegangen und der java-Befehl sucht nicht automatisch im aktuellen Verzeichnis nach der .class-Datei. Es soll jetzt nicht besprochen werden, was da schief gelaufen ist. Ein einfacher Ausweg ist aber, dass man beim Aufruf von java ausdrücklich angibt, dass java im aktuellen Verzeichnis nach Klassen suchen soll. Das geht dann so:

c:\programme\java\jdk\bin\java -cp . Test Susi

Der Punkt steht für das aktuelle Verzeichnis.

Die ersten Programme haben keine schöne Oberfläche; sie laufen einfach im Textmodus. Trotzdem müssen sie nicht dumm oder langweilig sein! Schon im Textmodus kann man Daten eingeben, verarbeiten und Ergebnisse ausgeben, und das ist der Kern eines jeden Programms.

Die Ausgabe ist überhaupt kein Problem, es gibt ja die Befehle

  System.out.print("Hallo ihr ");
  System.out.println(""+(1+1)+" Turteltäubchen!");

print schreibt etwas hin und belässt den Cursor hinter dem letzten geschriebenen Zeichen. Die nächste Ausgabe wird also nahtlos dahinter angefügt.

println schreibt ebenfalls etwas hin, geht abschließend aber an den Anfang der nächsten Zeile. Die obigen beiden Befehle schreiben also

Hallo ihr 2 Turteltäubchen!

auf den Bildschirm und fangen dann eine neue Zeile an. Der nächste Schreibbefehl würde also unter dem H anfangen.

Eingabe gibt es in zwei Formen. Wenn der Benutzer vor dem Start des Programms schon weiß, wie viele und welche Daten er eingeben will, so kann er diese Daten direkt nach dem Programmnamen beim Start des Programms angeben. Im Programm hat er Zugriff auf diese Daten über das Array args (siehe im Beispiel weiter oben.)

Die zweite Form der Eingabe verwendet man, wenn man die Daten erst eingeben will, sobald das Programm schon läuft. Man braucht dazu einen Scanner, der die Systemeingabe einfängt. Die erste Zeile des folgenden Beispiels schreibt man einmal am Anfang des Programms. Ab dann kann man die Tastatureingabe beliebig oft ansprechen mit z.B. tastatur.nextInt()

  java.util.Scanner tastatur=new java.util.Scanner(System.in);
  System.out.print("Wie viele seid ihr? ");
  int anz=tastatur.nextInt();
  System.out.println("Hallo ihr "+anz+" Turteltäubchen!");

Außer nextInt() für ganze Zahlen gibt es noch nextDouble() für Kommazahlen oder next() für irgendeine Buchstabenfolge. Mit hasNext() kann man testen, ob noch etwas kommt.

In Java gibt es eine große Menge von vorgefertigten Programmpaketen, die man als brauchbare Teile von eigenen Projekten verwenden kann. Diese Pakete befinden sich nach der Installation auf dem Rechner (gepackt in .jar-Dateien). Was es gibt und wie man es verwendet, muss man aber erst einmal wissen.

Wie gelangt man zu diesem Wissen? Das ist ein langsamer Prozess, bei dem man anderen Programmierern zusieht und sich mit ihnen austauscht. Der grundsätzliche Zugang ist aber immer die mitgelieferte Dokumentation. Diese besteht aus tausenden .html-Dateien, die mit einem Browser gelesen und durchsucht werden können.

Die Dokumentation sollte man sich auf seinen Rechner holen, damit man sie immer zur Verfügung hat. Man bekommt sie als große .zip-Datei, die man an eine beliebige Stelle auspackt, sagen wir ins Verzeichnis …/java/docs/. Eine der Dateien heißt dann docs/api/index.html und ist der Startpunkt der ganzen Dokumentation. Auf diese Datei sollte man im Browser ein Lesezeichen setzen.

Die große .zip-Datei gibt es für jede Java-Version an der gleichen Stelle, wie schon die ganze Java-Installation (siehe obige Beschreibung der Java-Installation). Wenn man einen schnellen Netzzugang hat, kann man die Dokumentation aber auch im Internet finden. Für Java 1.6 ist sie bei http://docs.oracle.com/javase/7/docs/api/.

Die Dokumentation wird mit einem Browser gelesen. Sie wird dargestellt als eine Seite mit drei Frames. Der rechte, große Frame zeigt dabei den Inhalt an, der im linken unteren Frame ausgewählt wurde. Was der linke untere Frame zur Auswahl anbietet, kann im linken oberen Frame nochmals eingeschränkt werden, weil die Menge so riesig ist. Lassen Sie im linken oberen Frame aber die erste Zeit die Wahl auf All Classes, dann entgeht Ihnen nichts.

Als Beispiel wollen wir mit Hilfe des Kosinus-Satzes die dritte Seitenlänge eines Dreiecks ausrechnen, von dem zwei Seiten und der eingeschlossene Winkel gegeben sind.

public class Seite{
  public static void main(String[] args){
    double a=Double.parseDouble(args[0]);
    double b=Double.parseDouble(args[1]);
    double gamma=Double.parseDouble(args[2])*Math.PI/180;
    double c=a*a+b*b-2*a*b*Math.cos(gamma);
    c=Math.sqrt(c);
    System.out.println("c="+c);
  }
}

Das Programm wird mit drei String-Argumenten aufgerufen, z.B.

java Seite 2.4 3.2 72

mit dem Ergebnis

c=3.35462352083

In diesem Programm werden zwei Java-Klassen verwendet Math und Double. Wenn man sich die in der Dokumentation anschaut, erfährt man schnell, dass parseDouble aus einem String eine Kommazahl macht, dass Math.PI der Wert von π ist und dass Math.cos den Kosinus eines Winkels im Bogenmaß ausrechnet. Außerdem bekommt man mit Math.sqrt die Wurzel berechet. (Die Zeile double c=… berechnet ja erst einmal nicht c sondern c², was übrigens kein schöner Stil ist.)

Auf dieser Seite lesen Sie, wie ich mich dazu bringe, Fehler zu vermeiden oder nicht vermiedene Fehler aufzuspüren. Natürlich bin ich unheimlich schlau und erfahren und mache keine Fehler. Jedoch gibt es immer wieder Momente, wo mein Unterbewusstsein dies ignoriert und mich wie einen Deppen dastehen lässt.

Wenn Sie im Laufe des Unterrichts den Eindruck gewinnen, dass Sie mehr Fehler machen als ich und auch noch länger brauchen, um sie zu finden, dann ist dieser Abschnitt für Sie interessant.

• Ich achte immer strengstens auf korrekte Einrückung. Da ich meinen Editor gut beherrsche, fällt mir das nicht schwer. Beherrsche deinen Editor!
• Alles was ich schreibe, muss spätestens wenige Minuten nach dem aktuellen Schreibvorgang schon wieder kompilierbar sein.
• Die main-Methode ist das erste, was ich schreibe. Sie erzeugt Hilfsobjekte, mit denen ich die anderen Methoden teste. Ganz am Schluss wird die main entfernt. Sie gehört normalerweise nicht in eine Klassendatei. Nur in einem Hauptprogramm ganz am Schluss eines Projektes braucht man sie wirklich, bei der Entwicklung aber nur zwischendurch.
• Ich versuche, zu jeder Zeit möglichst wenige Methoden (idealerweise nur eine einzige) zu bearbeiten und parallel aus der main heraus zu testen. (In der 11. Klasse bin ich die meiste Zeit sowieso nur in der main.)
• Während der Testphase sind Schweinereien erlaubt. Am Ende müssen die aber raus aus der Klasse. System.out.println ist normalerweise eine Schweinerei, die höchstens in einer static-Methode eine Existenzberechtigung hat.

Der Entwicklungszyklus ist die Abfolge von Tätigkeiten, die man durchläuft, während man ein Programm implementiert (schreibt).

Wenn man Glück hat, hilft einem der Compiler ausreichend, um alle Probleme zu finden und zu beheben. Das ist bei einfachen Programmen, wie sie in der Schule auftreten, oft der Fall.

1. Starten der benötigten Programme: In einfachen Fällen (Schulbeispiele) reicht da ein Konsolenfenster und ein Editor. Ich öffne also ein Konsolenfenster und navigiere an die Stelle, wo das Programm liegen soll. Vielleicht muss ich noch ein Verzeichnis anlegen. Wenn ich mich im Zielverzeichnis befinde, öffne ich aus der Konsole heraus meinen Lieblingseditor. Den Dateinamen der zu bearbeitenden Datei gebe ich gleich an, das spart Zeit!
2. Ich schreibe das Klassengerüst mit einer main-Methode. Die brauche ich, um alles zu testen. Wenn das Projekt aus mehreren Klassen besteht, werde ich diese main wahrscheinlich am Ende wieder löschen. Aber das Ende ist fern.
3. Ich speichere und kompiliere. Falls etwas schief gelaufen ist, ist es nicht viel und ich werde den Fehler leicht finden.
4. Ich verändere die Datei, füge Neues hinzu. Aber nicht viel, ein paar Zeilen vielleicht. Insbesondere bewege ich mich in der Datei nur an wenige Stellen, am besten nur eine.
5. Ich speichere und kompiliere. Falls etwas schief gelaufen ist, ist es nicht viel und ich werde den Fehler leicht finden.
   • Ich starte das Programm, um zu sehen, ob es korrekt funktioniert. Gut, dass das Programm eine main-Methode hat, sonst könnte ich es nicht starten.
   • Ich gebe beim Start gern Argumente auf der Kommandozeile mit, weil das schnell und unkompliziert geht. Natürlich musste ich hierfür in der main ein paar Zeilen schreiben, um die Argumente auch entgegennehmen und vielleicht umwandeln. Diese kleine Zusatzarbeit mache ich mir aber gern, weil danach alles viel schneller geht.
6. Wenn es Fehlermeldungen gibt, lese ich die erste aufmerksam und überfliege die anderen meist nur. Oft ist es nur ein Fehler, der zu vielen Meldungen führt.
   • Ich denke über die erste Meldung genau nach. Wenn ich sie verstanden habe, habe ich einen Fehler gefunden.
   • Wenn es ein logischer Fehler ist, dann probiere ich nicht herum, sondern denke nach. Herumprobieren führt oft dazu, dass das Programm etwas scheinbar richtig macht. Dafür verhält es sich aber gerade deswegen an einer anderen Stelle falsch. Weil ich nur herumprobiert habe, habe ich aber nichts verstanden und bin noch verwirrter als zuvor.
7. Wenn ich fertig bin, höre ich auf. Andernfalls weiter bei 4.

Bei halbwegs interessanten Programmen stößt man auf Fehler, die man nicht durch einfaches Lesen des Programmtextes herausfindet. Dann muss das Denken aus der aktuellen Bahn katapultiert werden. Die aktuelle Bahn fühlt sich super angenehm an. Man glaubt, dass man den vollen Überblick hat und dass der Computer böswillig ist. Das ist falsch.

1. Ich baue System.out.println-Befehle ein, um an wichtigen Stellen zu überprüfen, ob wirklich das rauskommt, was ich erwarte. Damit kann man einen Fehler sehr gut verfolgen, weshalb diese unscheinbare Technik auch bei Spitzenleuten die beliebteste ist.
2. Ich erkläre mein Programm einem kritischen Zuhörer. Dessen Zwischenfragen bringen mich auf das Problem oder ich merke während der Erklärung, dass ich Mist erzähle und der Fehler ist gefunden.
3. Als letzten Ausweg debugge ich das Programm. Dafür brauche ich eine Entwicklungsumgebung, die mir erlaubt, alle Variableninhalte zu beobachten, während ich Schritt für Schritt die Zeilen abarbeite. Das macht sogar eine Menge Spaß. Unangenehm ist nur, dass es so lange dauert und dass ich NetBeans starten muss. NetBeans braucht die Dateien aber an einer bestimmten Stelle, was zusätzlich Arbeit macht. Der JavaEditor ist eine Zwischenlösung: Der startet schneller, hat aber keine so schönen Anzeigemöglichkeiten.