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