Tutorium Java (Teil 1)


Vorwort, Motivation

Tutorien zu Java gibt es ja schon sehr viele. Deshalb soll dieses auch nicht der zigste Aufguss sein. Viel mehr sollen in diesem Tutorium, mit praktischen Beispielen, schnell Erfolgserlebnisse geschaffen werden. Nichts ist frustrierender, als in irgendwelchen sinnlosen Codefragmenten einen Fehler zu suchen. Dabei geht es nicht ohne Theorie, doch soll diese eher erklärend wirken, die Grundlage für ein nächstes Programm sein. Deshalb wird vielleicht auch der rote Faden nicht immer zu sehen sein. Dennoch werde ich alle relevanten Fakten, die wichtig sind, um Java effizient zu nutzen, auch anführen.
Ob nun dieses Tutorium das Verständnis für die Programmierprache Java und Objektorientierung erleichtert, kann ich nicht sagen. Ich hoffe das, weil ich selber weiß, wie ich Java gelernt habe und denke, die "Klippen", an denen man schnell "hängen bleibt", zu kennen.
Tja, woher soll nun die Motivation kommen? Zum einen ist das Tutorium im Aufbau, was bedeutet, dass ich noch nicht genau weiß, was ich im nächsten Teil schreiben werde. Ich möchte das auch offen lassen, von Teil zu Teil, weil ich gern Anregungen von euch (!) aufgreifen will. Ja, ein Tutorium, wo sich jeder vielleicht nachher wiederfindet!
Zum anderen sollen die Beispiele nicht nur zur Demonstration der Sprache selber dienen, viel mehr Hilfsmittel sein, mit denen man auch was anfangen kann. So wird sich viell. mancher überlegen, dieses oder jenes Beispiel nach eigenen Bedürfnissen "umzustricken". Dass ich dann gelegentlich in einigen Dingen vorgreifen werde, muss nicht beunruhigen. Alles wird im Nachhinein klarer werden!
Ich werde einige Dinge auch immer wieder in neuer Aufmachung präsentieren, weil es elementare Sprachelemente in Java gibt, die man aus dem Kopf wissen sollte.
Es wird also keine Vorlesung werden. Woran erkennt man eine gute Vorlesung? Dass man nur die ersten 10 min etwas versteht und den Rest nur mitschreibt ;o) Wer meine Zwischenkommentare langweilig findet und deshalb überspringen will, dem helfe ich dabei, indem ich die wichtigen Dinge schon hervorhebe :-))

Wie man wahrscheinlich schon merkt, will ich auch locker die Dinge beschreiben, was nicht heißt, dass die Fachbegriffe zu kurz kommen. Blos finde ich es nun wieder langweilig, sich durch "verfachsimpelten" Text zu quählen! Da kommen wir noch früh genug hin ;o)

So, nun Schluss der langen Vorrede, fangen wir einfach mal an!


Woher kommt Java ?

Typischer weise möchte ich nun erst mal beschreiben, woher Java kommt, was man alles damit programmieren kann, wann es sinnvoll ist nun gerade in dieser Sprache zu programmieren.
Keine Panik, ich werde nur einen kurzen Abriss zur Entstehung geben, Geschichte war noch nie mein Ding ;o) Alles begann mit dem "Green Project" 1991 an dem Patrick Naughton, James Gosling und Mike Sheridan beteiligt waren. Alle drei waren (sind) Programmierer bei SUN Microsystems. u.A. entstand neben einem "GreenOS", einem Grafiksubsystem und diversen Hardwarekomponenten ein Interpreter namens "Oak". "Oak" wurde später in "Java" umbenannt. Erst diente diese Sprache der Entwicklung von "WebRunner" (jetzt unter "HotJava" bekannt), einer Applikation, die schon ähnlich einem Webbrowser war, dann der Entwicklung des Java Compilers selbst. "HotJava" existierte 1995 neben Netscapes "Navigator". Netscape lizensierte Java und stellte am 23. Mai 1995 mit dem Navigator Java vor. Es wurde auch daran gearbeitet, die interne Sprache des Navigators "ActiveScript" mit Java kommunizieren zu lassen. "ActiveScript" ist heute unter "JavaScript" bekannt und das Zusammenspiel zwischen Java und JavaScript wird durch "LiveConnect" beschrieben (Methoden sind in "netscape.javascript.*" zu finden). 1996 erschien das erste jdk (java development kit = Java - Entwicklungs - Baukasten). Zu den Eigenschaften der folgenden Versionen komme ich später noch ausführlich.


Wozu gerade Java ?

Java ist besonders als Programmiersprache geeignet, wenn es darum geht, verteilte Software zu schreiben. Das heißt, Programme über das Internet geladen werden sollen. In vielen Homepages wird Java oder auch JavaScript eingesetzt, um eine Interaktion zu erreichen, die statische HTML - Seiten (HyperText Markup Language) nicht bieten können. Aber auch komplette Applikationen werden schon in Java programmiert (z.b. der "JBuilder" von Borland, ein IDE = Intergrated Development Environment - für Java). Java wird (noch) nicht verwendet, wenn es darum geht, zeitkritische Routinen zu schreiben, also Treiber oder Echtzeitanwendungen. Aber auch hier gibt es schon Lösungen, u.a. Echtzeit - VMs (Virtuelle Maschinen). Die Entwicklung von Java und Bibliotheken schreitet so rasant voran, dass es kaum noch ein Problemfeld gibt, wo Java keine Lösung bietet. Selbst "Oracle" verwendet in der 8.0i Version Java. D.h. Java ist keine Spielerei mehr, sondern eine vollwertige Programmiersprache!
Ich will an dieser Stelle keine Vergleiche bringen, das Für und Wider dieser und jener Programmiersprache aufzeigen. Sowas artet immer in philosophische Diskussionen aus und letztendlich ist man nicht schlauer, welche Sprache nun die beste ist. Ich beschreibe es mal so, mit Java kann ich ruhigen Gewissens heute fast jedes Problem angehen. Es soll aber jeder in der Sprache programmieren, die er gut beherrscht. Denn nur so kommt man zu schnellen Ergebnissen. Keiner fragt nachher, ob es in dieser oder jener Sprache geschrieben ist, außer ein anderer Programmierer ;o) Wer sich aber vorgenommen hat, eine Programmiersprache neu zu lernen, dem kann ich Java empfehlen.


Etwas zur Demotivation

Wir sitzen nun vor unserem Rechner. Dazu muss ich sagen, dass das schon mal sehr gut ist. Viele sagen zwar, dass "wildes Drauflosschreiben" doch kein programmieren, sondern "Hacken" wäre, doch muss jeder die Fehler selber machen und da kommen wir nicht drum herum, Code einzutippen und abzuändern.
Vorsicht, ich werde auch Fehler einbauen (ich hoffe nicht all zu oft unabsichtlich ;o), damit man ein Gefühl dafür bekommt, wie denn richtiger Code aussieht. Keine Sorge, die Auflösungen gibt es dann immer im nächsten Teil :-))

Achso, gleich noch vorweg! Ich muss all die enttäuschen, die erwarten, dass im Laufe dieses Tutoriums ein Ballerspiel a la "Doom" ... entsteht. Viele Beispiele werden in der Konsole ablaufen und weniger spektakulär sein. Doch wer den Sinn dahinter verstanden hat, dem verspreche ich, werden diese Beispiele ein Gewinn sein! Wir machen ja hier schließlich keine "Klickiprogrammierung"! *fg*


Voraussetzungen

Tja, und damit komme ich auch schon zu den Voraussetzungen, um in Java zu programmieren. Ein Streitpunkt ist immer, ob man schonmal vorher programmiert haben sollte. Einige meinen, dass Kenntnisse in prozeduraler Programmierung nur das Lernen einer objektorientierten Programmiersprache, wie dies Java ist, erschwert (was prozedural bzw. objektorientiert bedeutet, erkläre ich im nächsten Teil). Ich denke, dass einige Grundkenntnisse schon sinnvoll sind. Man also etwas anfangen kann mit "Assemblieren", "Compilieren" oder "Interpretieren" oder "Datentypen", "Variablen" etc. Ich gehe noch soweit, zu sagen, dass erst das wirkliche Verständnis für die Programmierung kommt, wenn man schon mal in Assembler etwas geschrieben hat. Erst dann kann man einschätzen, was abstraktere Programmiersprachen leisten. Wer in C++ programmiert hat, dürfte nur wenig Umstellungsschwierigkeiten haben, da Java ein "einfacheres" C++ darstellt. Aber, keine Panik, wer auch noch nicht programmiert hat, wird das Tutorium bestimmt verstehen. Wenn nicht, dann schreibt bitte, dass ich "kürzer treten" soll, bzw. manche Dinge genauer ausführe!

Man verfällt schnell darin, eine Programmiersprache nach ihrem Bibliotheksumfang zu beurteilen, d.h. auf welchen vorgefertigten Code ich schon zurückgreifen kann. Doch machen für mich eine Programmiersprache aus, die Philosophie, wie man zu universellem Code kommt, wie logisch und erweiterbar sie ist. Java ist nicht ganz so kompliziert und "fehlertolerant" wie C++, doch komplexer als BASIC. Naja, wenn wir weiter fortgeschritten sind, werden viele sagen, dass Java doch recht einfach ist.

Nachdem ich etwas zu den perönlichen Voraussetzungen gesagt habe, komme ich zu physischen, d.h. alle denen, die es rein rechentechnisch ermöglichen, Programme zu schreiben. Wir werden uns auf das jdk1.3 stützen. Ach so, weil ich schon gerade anfange mit Abkürzungen "um mich zu werfen" und auch noch englische, ist es unumgänglich, etwas Englisch zu lernen. Viele Entwicklungen stammen aus Amerika und somit bleibt es nicht aus, eben englische Begriffe zu lernen. Ein Griff zum Dictionary (sorry, Wörterbuch) lässt sich also in einigen Fällen leider nicht ersparen.


Installation des jdk

Da dieses jdk kostenlos ist, lässt es sich einfach von www.java.sun.com herunterladen. Es gibt mehrere Versionen, die zum einen die Entwicklungsstufe betreffen und zum anderen das Betriebssystem, für das die virtuelle Maschine funktioniert. Virtuelle Maschine? Erklärung kommt nach der Installationsbeschreibung! Genauso, wie ich später noch etwas zu den Versionen erklären werde.

Also, nachdem wir nun das jdk zur Verfügung haben, kommen wir jetzt zur Installation. Da ich denke, dass die meissten unter Windows arbeiten, beschränke ich mich mit meinen Hinweisen auch nur erstmal auf dieses Betriebssystem und die Version 1.3 des jdk.
Ein Doppelklick auf die exe - Datei und die Installation beginnt. Zum einen werden Lizenzbestimmungen angezeigt, die akzeptiert werden müssen, danach ein Pfad (z.b. "C:\java"), wohin alle Dateien kopiert werden sollen und dann die einzelnen jdk - Pakete. Den Pfad können wir so belassen und dann wählen wir alle Pakete aus. Nach ein paar Minuten sind dann auch schon alle Dateien unter angegebenem Pfad kopiert. Was jetzt noch fehlt, sind zwei Einträge in der "autoexec.bat":

(erster Eintrag setzt den Pfad für die ausführbaren Dateien des jdk)
SET PATH=%PATH%;.;C:\java\bin
(folgender Eintrag legt fest, wo die Klassenbibliotheken liegen)
SET CLASSPATH=%CLASSPATH%;.;C:\java\lib;c:\java\jre\lib\rt.jar
Durch diese Einträge werden die Umgebungsvariablen "PATH" und "CLASSPATH" festgelegt. Da auch andere Programme ausser dem jdk solche Pfad - Einstellungen setzen, müssen diese per "%(CLASS)PATH% angegeben werden. Der Punkt danach (zwischen zwei Semikolon) gibt an, dass in dem gerade eingestellten Verzeichnis auch gesucht werden soll. Das ist sehr praktisch, weil eigene Bibliotheken dann nicht unbedingt im Klassenpfad (hier "C:\java\lib") liegen müssen. "C:\java\lib;c:\java\jre\lib\rt.jar" ist nun kein Pfad, sondern gibt direkt die Klassenbibliothek des jdk an (was in der Version ab 1.2 nur noch optional ist). Diese Datei liegt in gepackter Form vor, deshalb die Endung "jar". Wer "zip" - Dateien kennt, versteht auch das jar. "jar" steht für Java Archive und ist ein ein Java Zip, wenn man so will. Mittels "jar.exe -x archive.jar" kann jedes "archive.jar" entpackt werden. "jar.exe" selbst ist Bestandteil des jdk und befindet sich im Verzeichnis "bin". Für unsere ersten Versuche kommen wir damit aber nicht in Berührung, da Programme, die diese gepackte Klassenbibliothek benötigen, sie auch auotmatisch vor deren Benutzung entpacken.
Weil ich grad bei des Syntax von jar bin, noch ein Hinweis, wie man seine Programme in jars "verpackt" und "java" übergeben kann, so dass es ausgeführt wird!
jar cfm main.jar manifest.txt pfad_der_Programmdateien/
"c" steht für das Anlegen eines neuen Java Archives, "f" für das Angeben eines Archivnamens und "m" für das Einfügen einer Manifest - Datei. Wird "m" nicht angegeben, so wird automatisch diese hinzugefügt zum Archiv unter dem Verzeichnis "Meta-inf" als "Manifest.mf". Eine Manifest - Datei enthält Informationen über das Archiv, z.B. von wem die Applikation programmiert wurde, welche Version vorliegt und welches Programm gestartet werden soll (steht nach dem Schlüsselwort "Main-Class:").
Ein Manifest - Datei könnte so aussehen:
Manifest-Version: 1.0
Main-Class: Notepad
Created-By: 1.3.0rc2 (Sun Microsystems Inc.)
Aufgerufen wird dieses Archiv dann mittels:
java -jar main.jar

Nach diesem "Zwischenausflug" kann der Rechner neu gestartet werden (keine Shift - Taste beim Neustart von Windows drücken, denn die "autoexec.bat" muss ja ausgeführt werden ;o) !)


Bestandteile des jdk

Damit will ich im Folgenden einmal einige Bestandteile des jdk kurz anhand des Verzeichnisbaumes erläutern:
- bin
  java
  appletviewer
  javac
  javadoc
  jdb
+ demo
  + applets
  + java3d
  + jfc
  + jpda
  + sound
+ jre
  + lib
    rt.jar

Im Verzeichnis "bin" liegen alle ausführbaren Dateien des jdk, so u.A. der Compiler ("javac"), die virtuelle Maschine ("java", "appletviewer"), ein Dokumentationsgenerator ("javadoc") und ein Debugger ("jdb"). Ich werde im ersten Teil nur einige dieser Programme behandeln, genau die, die nötig sind, um schon einmal ein paar Beispiele des jdk ausprobieren zu können. Viele Beispiele sind im Verzeichnis "demo" zu finden. In "jre" befindet sich unter "lib" die Klassenbibliothek von Java. Diese bietet viele vorgefertigte Klassen an, die die Programmierarbeit unterstützen. Wir werden schon in diesem Teil diese Klassen nutzen. Dafür haben wir ja vorhin schon den Klassenpfad in der "autoexec.bat" festgelegt.


Merkmale von Java

Java Code wird compiliert, d.h. so ein richtiges Compilat wie man es z.B. von einem C Compiler gewöhnt ist, ist es bei Java nicht. Das deshalb, weil per "javac classname.java" comilierter Code nicht direkt lauffähig ist. Java benötigt eine sogenannte "virtuelle Maschine". Wie der Name schon sagt, stellt dieses Programm eine Art Rechner dar, der eben diesen compilierten Code versteht, interpretiert. Wenn man so will hat man eine Verschmelzung von Compiler und Interpreter. Gerade aber dieses Konzept macht Java weitestgehend (zu Einschränkungen komme ich noch) plattformunabhängig. Nun gibt es einen Unterschied bei den virtuellen Maschinen. Das liegt daran, dass es zum einen Java - Programme gibt, die im Web - Browser laufen sollen und andere von einer Konsole aus. Erstere nennt man Applets und diese werden in einer HTML - Seite eingebunden (dazu komme ich im nächsten Teil noch genauer). Aufgerufen werden diese per Web - Browser, bzw. "appletviewer classstarter.htm(l)". "appletviewer" stellt einen Browser - Ersatz dar. Java - Programme, die von der Konsole aus aufgerufen werden, nennt man Applications. Die Aufrufsyntax lautet "java classname". Wo beim appletviewer die Endung (*.html, *.htm) angegeben werden muss, ist das hier nicht der Fall. Zum einen startet man ja direkt das "classfile" und das hat eine genormte Endung, nämlich "*.class", zum anderen können bei HTML Seiten die Endungen abweichen, eben der in 8.3 Konvention (also z.B. "abcdefgh.htm") von der "langen" Darstellung (*.html). Was ist nun das "classfile"? Das ist ist die Datei (Compilat), die nach Anwendung von "java classname.java" entsteht, d.h., wenn fehlerfrei compiliert wurde. Dabei ist das classfile gleichnamig der Klasse in der die "main()" - Funktion steht, bzw. die Methode(n) "init()"(, "start()"). Die "main()" - Funktion zeichnet Applications aus und die letzteren Methoden Applets. Eine Beispiel - Application sieht z.B. folgendermassen aus:
/*********************************************************
 *  unsere 1st Application, die "Hello world!" ausgibt
 *  erstellt am: 25.1.2k1
 *********************************************************/
public class HelloWorldApplication {
   public static void main( String[] args ) {
      System.out.println( "Hello world!" );
   }//public static void main( String[] args )
}//public class HelloWorldApplication

Abbildung 1: Application "HelloWorld"

Wir können ja diese Application gleich einmal ausprobieren, indem wir erst mal den Text (in Abbildung 1) in einen ASCII Texteditor (z.B. Notepad oder UltraEdit) übernehmen und unter dem Namen "HelloWorldApplication.java" abspeichern, z.B. unter "C:\tmp". Dann Compilieren wir den Code, indem wir in der MS-DOS-Eingabeaufforderung "javac HelloWorldApplication.java" eingeben. Das enstehende Classfile kopieren wir in das Verzeichnis "classes".
Ein Applet unterscheidet sich eben darin, dass statt dem statischen "main()" eine dynamische Methode "start()" existiert. Was "statisch" und "dynamisch" bedeutet, werde ich im Zusammenhang mit der Objektorientierung erklären. In dem Applet (Abbildung 2) könnte auch die Methode "init()" genutzt werden, diese wird nur zeitiger als "start()" aufgerufen. Der Lebenszyklus eines Applets besteht also in dem Nacheinanderaufrufen folgender Methoden: "init()" => "start()" => "paint()" => "stop()" => "destroy()".
/*********************************************************
 *  unser 1st Applet, das "Hello world!" ausgibt
 *  erstellt am: 25.1.2k1
 *********************************************************/
public class HelloWorldApplet {
   public void start() {
      System.out.println( "Hello world!" );
   }//public void start()
}//public class HelloWorldApplet

Abbildung 2: Applet "HelloWorld"

Wie ich schon zuvor beschrieben habe, werden Applets per Web - Seite im Browser oder per "appletviewer start.htm(l)" gestartet, sodass also zu jedem Applet noch eine HTML - Seite gehört (Abbildung 3 für Applet in Abbildung 2).
<HTML>
  <HEAD>
    <TITLE> HTML Seite für Applet </TITLE>
  </HEAD>
  <BODY>
    <APPLET CODE="HelloWorldApplet.class" 
       ARCHIVE="main.jar"
       CODEBASE="../classes/HelloWorldApplet/" 
       WIDTH="0" HEIGHT="0">
       <PARAM NAME=parameter_Text VALUE="Text">
       <PARAM NAME=parameter_Zahl VALUE=1024>
       <PARAM NAME="parameter_Link" VALUE="../tmp/pic.gif">
    </APPLET>       
  </BODY>
</HTML>

Abbildung 3: HTML Seite, mittels derer Applet "HelloWorld" (Abbildung 2) aufgerufen wird

Das Tag "<APPLET>" leitet einen Applet - Eintrag in HTML ein. "CODE=" gibt den Namen des zu startenden Applets an, hier also "HelloWorldApplet.class". Da dieses Applet nicht im selben Verzeichnis wie diese HTML Seite liegt (siehe Verzeichnisbaum in Abbildung 4), sondern in "classes", kann eine "CODEBASE=" angegeben werden. Dahinter steht nun der Pfad, in dem das Applet liegt. Die Notation ist an Unix angelehnt, deshalb wechselt man mit ".." das Verzeichnis um eine Ebene nach oben, weil wir uns ja jetzt noch in "html" befinden und mit "/classes/HelloWorldApplet/" in das Verzeichnis, wo eben unser Applet liegt. Es werden keine backslashes ("\"), stattdessen slashes ("/") geschrieben. "ARCHIVE=" legt die jar - Datei fest aus der die in "CODE=" stehende Klasse stammt. Ein Archiv zu verwenden, hat den Vorteil, weniger Daten über das Netz auf den Client laden zu müssen. Kann das Archiv nicht auf den Client geladen werden, versucht der Browser die ungepackte Klasse zu laden. Dazu ist es nötig, neben dem Archiv dann auch die ungepackten Dateien auf dem Server verfügbar zu halten.
Damit ist die Definition des Applets noch nicht abgeschlossen. Applets geben ihre Grafiken und Texte auf der Web - Seite aus, deshalb muss ein Bereich dafür in Bildpunkten angegeben werden. "WIDTH=" gibt dabei die Breite des Ausschnittes und "HEIGHT=" die Höhe an. Da das Applet genau das selbe, wie die Applikation ausführen soll, nämlich "HelloWorld" in einer Konsole ausgeben, setzen wir hier die Breite und Höhe zu "0".
..
+ /classes/
  + /HelloWorldApplication/
    HelloWorldApplication.class
    main.jar
    manifest.txt
  + /HelloWorldApplication/
    HelloWorldApplet.class
    main.jar
    manifest.txt
+ /html/
  HelloWorldApplet.html
+ /src/
  HelloWorldApplication.class
  HelloWorldApplet.class

Abbildung 4: Verzeichnisbaum

Tja, nur wo bleibt, dann unsere Ausgabe, wenn eben nicht auf der Web - Seite? Anders gefragt, wo habe ich bei einem Browser eine Konsole? Gut, da es mehrere Browser gibt und den Appletviewer, wird die Java - Konsole auch jeweils unterschiedlich aufgerufen. Ich "reite" so auf der Konsole "herum", weil sie später unsere erste Hilfe sein wird, wenn es darum geht, Fehler in einem Applet aufzuspühren.
Beim Netscape - Browser können wir diese Konsole über das Menü "Communicator->Tools->Java Konsole" öffnen. Diese Konsole sieht unscheinbar aus, doch mit dem Fragezeichen, was man einfach eintippen kann (ohne enter), erscheinen mehr Optionen. So können u.a. der Garbage Collector (räumt den Speicher auf) gestartet [g], der Fensterinhalt gelöscht [c] (es werden sonst alle neuen Ausgaben, an die bisherigen angehangen) oder der durch Applets genutze Speicher angezeigt [m] werden. Wir sehen in dieser Konsole auch jetzt unsere Ausschrift vom Applet "Hello World!".
Beim Microsoft Internet Explorer gibt es diese Konsole erst, nachdem man sie "freigegeben" hat. Dazu muss man zuvor im Menü "Extras" Internetoptionen aufrufen. Unter der Karteikarte "Erweitert" gibt es im Abschnitt "Java VM" einen Eintrag "Java-Konsole aktiviert (Neustart erforderlich)", der zu wählen ist. Nach Neustart des Browsers kann man diese Konsole dann per Menü - Eintrag "Ansicht -> Java-Befehlszeile" aufrufen. Eine praktische Erweiterung hat diese Java-Konsole gegenüber der von Netscape, hier können nämlich alle laufenden Threads (hier erstmal vereinfacht ausgedrückt, laufende Java Programme) per "t" ausgegeben werden. Wenn wir das mal probieren wird in der Konsole u.a. unser Applet angezeigt (thread applet-HelloWorldApplet.class). Nun gibt es neben unserem Thread (also dem HelloWorldApplet) noch weitere, zu dessen Bedeutung ich später noch kommen werde, wenn es damum geht, solche Threads in einem eigenen Java Programm zu erzeugen.
Wie sieht es nun beim Appletviewer aus? Hier ist die Konsole unsere MS-DOS-Eingabeaufforderung, von der also der appletviewer gestartet wird. Geben wir also
"c:\java_kurs_teil_1\html> appletviewer HelloWorldApplet.html"
ein, so erscheint unser
"Hello World!"
in der MS-DOS-Konsole. Ein Promt erscheint jedoch nicht, da ja der Appletviewer noch läuft.
Doch kommen wir zurück zu unserer Definition eines Applets in der HTML.
Einem Applet können mehrere Parameter, wie einer Applikation auch übergeben werden. Diese werden bei der Applikation einfach nach dem Klassennamen mit Leerzeichen getrennt angegeben, in der HTML - Seite für das Applet jeweils per Schlüsselwort:
<PARAM NAME=parameter_Text VALUE="Text">
"NAME=" beschreibt den Parameternamen unter dem im Applet der Wert (nach "VALUE=" stehend) ausgelesen werden kann. Zur Ausprogrammierung dieser Parameterübergabe komme ich im nächsten Teil.
Jetzt sollten alle notwendigen Dinge beschrieben sein, die es ermöglichen, die mitgelieferten Beispiele des jdk (im Verzeichnis "demo") auch auszuprobieren. Zu beachten ist jeweils, ob eine Applikation oder ein Applet vorliegt, dementsprechend die virtuelle Maschine (der Aufruf) zu wählen.

----------- Spicker -----------

In diesem Abschnitt werde ich immer die wichtigsten Dinge eines Kurses in komprimierter Form noch einmal zusammenfassen. So muss man später nicht unbedingt den kompletten Kurs durchlesen. Ich überlege mir noch, eine Suchfunktion zu implementieren (könnte ja schon ein Java Applet sein).

Pfade für das jdk:
SET PATH=%PATH%;.;C:\java\bin
(für ausführbare Dateien)
SET CLASSPATH=%CLASSPATH%;.;C:\java\lib;c:\java\jre\lib\rt.jar
(für Klassenbibliotheken)

Ausführen von Applikationen:
java startKlasse
java -jar main.jar
("startKlasse" ist die Klasse, in der die main - Funktion definiert ist; das ".class" ist nicht anzugeben! -
"main.jar" enthält die "startKlasse" und muss, um gestartet zu werden, in einer Manifest - Datei angegeben werden)


Ausführen von Applets:
appletviewer startKlasse.htm(l)
(dabei ist "startKlasse.htm(l)" die Seite, in der das Applet definiert ist)

Packen von Dateien:
jar cfm main.jar manifest.txt pfad_der_Programmdateien/


Compilieren:
javac classname.java
--- Copyright © 2001 Thomas Funke (Stand: 3.1.2001) --