Applikationen mit Java Tutorial

18.01
Untersuchen der
Programmiersprache Java
und entwickeln von DemoApplikationen mit Java
Tutorial
AUTOR:
J.-P. Thomsen
BETREUER:
H.-J. Wenger
KLASSE:
B17
Grenchen, den 10.6.96
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
Inhalt
2
Inhalt
INHALT............................................................................................... 2
1 EINFÜHRUNG ................................................................................... 7
1.1 Was ist Java? ..........................................................................................................7
1.1.1 WAS SIND JAVA-APPLETS ?..................................................................................... 8
1.1.2 WAS IST HOTJAVA ? ................................................................................................. 8
1.1.3 WAS SIND JAVA-GESTEUERTE SEITEN ? .............................................................. 8
1.2 Die Geschichte der Programmiersprache Java.......................................................9
1.2.1 DIE ANFÄNGE ............................................................................................................ 9
1.2.2 DAS GREEN-PROJEKT............................................................................................. 10
1.2.3 WEBBROWSER UND HOTJAVA.............................................................................. 10
1.2.4 WAS BEDEUTET JAVA ? ......................................................................................... 11
1.3 Die wichtigsten Eigenschaften...............................................................................12
1.3.1 JAVA IST EINFACH UND UNKOMPLIZIERT ......................................................... 12
1.3.2 JAVA IST OBJEKTORIENTIERT.............................................................................. 12
1.3.3 JAVA IST ROBUST ................................................................................................... 14
1.3.4 JAVA IST SICHER..................................................................................................... 14
1.3.5 JAVA IST PARALLELISIERBAR, MULTITHREADED............................................ 14
1.3.6 JAVA-PROGRAMME SIND SCHON KOMPILIERT................................................. 15
1.3.7 JAVA IST PLATTFORMUNABHÄNGIG .................................................................. 15
1.3.8 JAVA IST ERWEITERUNGSFÄHIG ......................................................................... 16
1.3.9 JAVA IST GUT ERFORSCHT.................................................................................... 16
2 JAVA UND DAS INTERNET .............................................................. 17
2.1 Die Java-Applets ...................................................................................................18
2.2 Sicherheitsaspekte.................................................................................................18
2.2.1 DIE VERIFIZIERUNG ............................................................................................... 19
2.2.2 ZUGRIFFSMÖGLICHKEITEN .................................................................................. 19
2.3 Die virtuelle Maschine...........................................................................................20
2.4 Applets und Anwendungen ...................................................................................20
2.4.1 APPLETS ................................................................................................................... 20
2.4.2 ANWENDUNGEN ..................................................................................................... 21
2.5 JavaScript .............................................................................................................21
3 DIE SPRACHE JAVA ....................................................................... 22
3.1 Unterschiede zu C/C++ .........................................................................................22
3.1.1 KEINE HEADER FILES UND PRECOMPILER......................................................... 22
3.1.2 KEINE STRUKTUREN UND UNIONS...................................................................... 23
3.1.3 KEINE FUNKTIONEN............................................................................................... 23
3.1.4 KEINE MEHRFACHVERERBUNG ........................................................................... 23
3.1.5 KEINE GOTO-BEFEHLE........................................................................................... 23
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
Inhalt
3
3.1.6 KEIN ÜBERLADEN VON OPERATOREN ............................................................... 23
3.1.7 KEINE AUTOMATISCHE TYPENUMWANDLUNG................................................ 24
3.1.8 KEINE POINTER UND POINTERARITHMETIK ..................................................... 24
3.1.9 KEINE VAGE DEFINIERTEN DATENTYPEN......................................................... 24
3.1.10 KEINE FREIE ARGUMENTENANZAHL (VARGS) ............................................... 24
3.1.11 KEINE SEMIKOLON ? ............................................................................................ 25
3.2 Überblick über die Syntax ....................................................................................25
3.2.1 KOMMENTARE ........................................................................................................ 25
3.2.2 EINFACHE DATENTYPEN....................................................................................... 25
3.2.3 REFERENZIERENDE DATENTYPEN...................................................................... 26
3.2.4 OBJEKTE ................................................................................................................... 27
3.2.5 MÜLLABFUHR, „GARBAGE COLLECTOR“........................................................... 29
3.2.6 ARRAYS .................................................................................................................... 30
3.2.7 ZEICHENKETTEN (STRINGS) ................................................................................. 31
3.2.8 ARITHMETISCHE UND RELATIONALE OPERATOREN....................................... 31
3.2.9 BEFEHLE................................................................................................................... 33
3.2.10 SCHLÜSSELWORTE ............................................................................................... 36
3.2.11 SYNCHRONISIERUNG ........................................................................................... 36
3.3 Ausnahmen (Exceptions + Exception Handling)...................................................37
3.3.1 AUSNAHME-OBJEKT............................................................................................... 38
3.3.2 BEHANDLUNG VON AUSNAHMEN ....................................................................... 38
3.3.3 DEFINITION UND ANWENDUNG VON AUSNAHMEN......................................... 39
3.4 Threads .................................................................................................................40
3.4.1 FUNKTIONSWEISE VON THREADS....................................................................... 40
3.4.2 SYNCHRONISATIONS-ANWEISUNGEN ................................................................ 41
3.5 Benennungskonventionen......................................................................................42
3.6 Die Java-Packages.................................................................................................43
4 OBJEKTE UND KLASSEN ................................................................ 44
4.1 Einführung in Klassen und Objekte......................................................................44
4.1.1 OBJEKTE ALS INSTANZEN VON KLASSEN ......................................................... 44
4.1.2 ZUGRIFF AUF OBJEKTDATEN ............................................................................... 45
4.1.3 GEBRAUCH VON OBJEKTMETHODEN ................................................................. 45
4.1.4 FUNKTIONSWEISE .................................................................................................. 45
4.2 Erzeugen von Klassen ...........................................................................................46
4.2.1 DEFINITION EINES KONSTRUKTORS ................................................................... 46
4.2.2 MEHRFACHE KONSTRUKTOREN .......................................................................... 47
4.2.3 ÜBERLADEN VON METHODEN ............................................................................. 47
4.3 Klassenvariablen ...................................................................................................48
4.3.1 BEISPIEL EINER KLASSENVARIABLEN ............................................................... 48
4.3.2 ZUGREIFEN AUF KLASSENVARIABLEN .............................................................. 49
4.3.3 GLOBALE VARIABLEN ?......................................................................................... 49
4.3.4 KONSTANTEN.......................................................................................................... 49
4.4 Klassenmethoden ..................................................................................................49
4.4.1 BESONDERE MERKMALE....................................................................................... 50
4.4.2 BEISPIEL EINER KLASSENMETHODE................................................................... 50
4.4.3 STATISCHE INITIALISIERUNG............................................................................... 51
4.5 Löschen von Objekten ..........................................................................................51
4.5.1 GARBAGE COLLECTOR .......................................................................................... 51
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
Inhalt
4
4.5.2 FINILIZATION-METHODE....................................................................................... 51
4.6 Klassenhierarchie und Vererbung ........................................................................52
4.6.1 VERERBEN VON KLASSEN .................................................................................... 52
4.6.2 ENDKLASSEN........................................................................................................... 52
4.6.3 KLASSENHIERARCHIE............................................................................................ 53
4.6.4 UNTERKLASSEN UND KONSTRUKTOREN........................................................... 53
4.6.5 VERKETTUNG VON KONSTRUKTOREN............................................................... 54
4.6.6 DER DEFAULT-KONSTRUKTOR ............................................................................ 55
4.7 Überschreiben von Methoden ...............................................................................55
4.7.1 FINALE METHODEN................................................................................................ 56
4.7.2 DYNAMISCHES NACHSCHLAGEN DER METHODE ............................................ 56
4.7.3 AUFRUFEN EINER ÜBERSCHRIEBENEN METHODE ........................................... 56
4.7.4 VERKETTUNG VON FINALIZER-METHODEN...................................................... 56
4.8 Geheimhaltung und Datenkapselung.....................................................................57
4.8.1 SICHTBARKEIT VON DATEN, METHODEN, KLASSEN....................................... 57
4.8.2 DATENZUGRIFF DER METHODEN ........................................................................ 58
4.9 Abstrakte Klassen und Interfaces .........................................................................59
4.9.1 ABSTRAKTE METHODEN....................................................................................... 59
4.9.2 INTERFACES ............................................................................................................ 59
4.9.3 MEHRFACHE INTERFACES .................................................................................... 60
4.9.4 KONSTANTEN UND INTERFACES......................................................................... 60
4.9.5 VERERBUNG (ERWEITERUNG) VON INTERFACES............................................. 60
5 PROGRAMMIERUNG ...................................................................... 62
5.1 Applets ..................................................................................................................62
5.1.1 EINFÜHRUNG IN APPLETS ..................................................................................... 62
5.1.2 DAS ERSTE APPLET ................................................................................................ 63
5.1.3 ZEICHNEN VON GRAPHIKEN................................................................................. 64
5.1.4 BEHANDLUNG VON EREIGNISSEN....................................................................... 64
5.1.5 DER EVENT-HANDLER ........................................................................................... 65
5.1.6 LESEN VON APPLET-PARAMETERN..................................................................... 66
5.1.7 EINFÜGEN VON SCHALTFLÄCHEN ...................................................................... 66
5.1.8 IMAGEMAP (BILDERKARTE) ................................................................................. 67
5.1.9 ANIMATIONEN ........................................................................................................ 67
5.1.10 SOUND..................................................................................................................... 68
5.2 Graphical User Interface (GUI)............................................................................68
5.2.1 DIE WICHTIGSTEN KLASSEN ................................................................................ 68
5.2.2 DIE KLASSE EVENT ................................................................................................ 69
5.2.3 DIE KLASSE COMPONENT ..................................................................................... 70
5.2.4 DIE KLASSE CONTAINER....................................................................................... 71
5.3 Eingabe und Ausgabe............................................................................................72
5.3.1 LESEN UND ANZEIGEN VON FILES ...................................................................... 72
5.3.2 BESCHAFFUNG VON DATEI-INFORMATION ....................................................... 72
5.3.3 KOPIEREN EINES FILES.......................................................................................... 72
5.3.4 FILTERN VON EINGABEN ...................................................................................... 72
5.3.5 PIPES.......................................................................................................................... 73
5.4 Networking............................................................................................................73
5.4.1 HERUNTERLADEN VON URL-INHALTEN............................................................. 74
5.4.2 BENUTZUNG EINER URL-VERBINDUNG.............................................................. 74
5.4.3 SENDEN UND EMPFANGEN VON DATENPAKETEN........................................... 74
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
Inhalt
5
5.4.4 IMPLEMETIERUNG EINES SERVERS .................................................................... 76
5.4.5 IMPLEMETIERUNG EINES CLIENTS ..................................................................... 76
5.5 Kommunikation zwischen Applets ........................................................................77
5.5.1 APPLETS AUF DER SELBEN SEITE........................................................................ 77
5.5.2 KOMMUNIKATION MIT DEM BROWSER.............................................................. 77
5.5.3 ARBEITEN MIT SERVER-APPLIKATIONEN.......................................................... 78
5.5.4 UMGEHEN DER EINSCHRÄNKUNGEN.................................................................. 78
5.5.5 MÖGLICHKEITEN UND EINSCHRÄNKUNGEN..................................................... 78
A JAVA DEVELOPMENT KIT (JDK) ................................................. 80
A.1 Der Applet Viewer (appletviewer) .......................................................................80
A.2 Der Interpreter (java) ..........................................................................................80
A.3 Der Compiler (javac)............................................................................................81
A.4 Der Dokument-Generator (javadoc) ....................................................................81
A.5 Native Method C File Generator (javah) .............................................................81
A.6 Class Disassembler (javap)...................................................................................81
A.7 Debugger (jdb) .....................................................................................................82
B ENTWICKLUNGS-TOOLS............................................................... 83
B.1 Silicon Graphics: Cosmo Code.............................................................................83
B.2 BulletProof: JAGG...............................................................................................83
B.3 Kinetix: Hyperwire ..............................................................................................84
B.4 Aimtech: Jamba....................................................................................................84
B.5 Rogue Wave Software: JFactory .........................................................................84
B.6 Thought Inc.: Nutmeg ..........................................................................................84
B.7 Spider Technologies: NetDynamics......................................................................85
B.8 Symantec: Symantec Café ....................................................................................85
B.9 PowerProduction Software: WebBurst................................................................85
B.10 Microsoft: Visual J++.........................................................................................85
B.11 SUN Microsystems: Java Workshop .................................................................86
B.12 Innovative Software: OEW................................................................................86
B.13 FishNet: Kawa:...................................................................................................86
B.14 PowerSoft: Optima++ ........................................................................................86
B.15 Natural Intelligence: Roaster .............................................................................87
B.16 melonSoft Berlin: ACupOfCoffee.......................................................................87
B.17 Borland: Latte ....................................................................................................87
C UNTERSCHIEDE C++ / JAVA ........................................................ 88
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
Inhalt
6
D WEITERE INFORMATIONEN.......................................................... 90
D.1 Bücher ..................................................................................................................90
D.2 Internet.................................................................................................................92
E GLOSSAR ...................................................................................... 94
F ABBILDUNGEN, TABELLEN ........................................................... 96
F.1 Abbildungen..........................................................................................................96
F.2 Tabellen ................................................................................................................96
G STICHWORTVERZEICHNIS ............................................................ 97
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
1 Einführung
7
1 Einführung
Nach dem Domain Name System und dem World Wide
Web (WWW) stehen nun im Internet neue Umwälzungen
an. Es könnte sich dabei um die Auswirkungen der von
SUN Microsystems entwickelten Programmiersprache Java handeln.
direkt ausführbare
Programme
Durch Java hört das WWW wahrscheinlich auf, „nur“ ein
Informationssystem zu sein. Es wird zur zentralen Infrastruktur für den Austausch von Informationen, Daten und direkt
ausführbaren Programmen. Denn Java hat die einzigartige Fähigkeit, in Binärform auf allen populären Architekturen im Internet ausführbar zu sein. Ein Mausklick genügt,
um durchaus komplexe Anwendungen irgendwoher aus
dem Netz auf den eigenen Rechner zu laden und auszuführen. Damit hat Java gute Chancen, sich als InternetProgrammiersprache schlechthin zu etablieren.
1.1 Was ist Java?
Java vereint viele
Vorteile
Java ist eine Programmiersprache, bei welcher versucht
wurde, die Vorteile der bekannten Programmiersprachen
zu übernehmen und gleichzeitig deren Nachteile auszubügeln. Java ist rein objektorientiert und hat keine strukturellen Überbleibsel, wie das z.B. bei C++ der Fall ist. Java
sollte alles enthalten, was das Programmieren angenehm
macht und dabei mit einer klar überschaubaren und redundanzfreien Syntax auskommen.
SUN beschreibt Java in ihrem „The Java Language: A White Paper“ wie folgt:
Java:
A simple, object-oriented- distributed, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded and
dynamic language.1
„Java in a Nutshell“ [Nutshell], David Flanagan, O’Reilly &
Associates Inc., 1996, First Edition, Seite 4
1
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
8
1 Einführung
1.1.1 WAS SIND JAVA-APPLETS ?
Applets sind in
Web-Seiten eingebettet
Java-Applets sind kleine, in Java geschriebene Programme, die in Web-Seiten eingebettet werden, um besondere Effekte zu erzielen.
Wenn der Benutzer diese Seite aufruft, werden die Applets
in seinen Computer geladen und ausgeführt. Die Aktivität
findet also nicht auf der Seite des Servers statt, sondern
auf der des Anwenders und zwar in einem Java-kompatiblen Web-Browser. Das bedeutet, dass die Applets keinen
Einschränkungen durch die Bandbreite des Netzes oder
die Zugangsgeschwindigkeit des Modems unterliegen.
Der Benutzer sieht und hört Multimedia-Effekte auf den
Web-Seiten also besser und schneller.
Da Java eine leistungsfähige Programmiersprache ist, arbeiten die Applets im allgemeinen mit der gleichen Geschwindigkeit wie die anderen Applikationen auf einem
PC.
1.1.2 WAS IST HOTJAVA ?
HotJava war der
erste Java-kompatible Browser
HotJava ist ein von SUN Microsystems entwickelter WebBrowser, der es dem Benutzer ermöglicht, Javagesteuerte Web-Seiten aufzurufen.
Der Zugriff auf die oben beschriebenen Java-spezifischen
Effekte ist nur auf einem Java-kompatiblen Web-Browser
möglich. Der erste dieser Web-Browser war HotJava, der
vom Java-Team bei SUN Microsystems entwickelt wurde.
In der Zwischenzeit sind auch Java-kompatible WebBrowser von Netscape (Netscape Navigator ab Version
2.0), Microsoft (Internet Explorer), Oracle (Power Browser),
IBM (WebExplorer) u.a. auf dem Markt.
1.1.3 WAS SIND JAVA-GESTEUERTE SEITEN ?
Java-gesteuerte Seiten sind Web-Seiten, in welche JavaApplets eingebettet sind, welche die verschiedensten
Spezialeffekte hervorrufen.
Solche Web-Seiten bieten zur Zeit die spektakulärsten Effekte, und ihre Anzahl steigt nahezu explosionsartig.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
9
1 Einführung
1.2 Die Geschichte der Programmiersprache Java
Aus der Geschichte einer Programmiersprache können
wir einiges über die betreffende Sprache lernen. In der
Entwicklungsphase ist es äusserst wichtig, die Sprache in
„echten“ Projekten zu verwenden. Andernfalls wird sie
nicht sehr nützlich sein bzw. der Umgang mit ihr ist zu wenig benutzerfreundlich.
ursprünglich für
Gerätesteuerung
Die Programmiersprache Java wurde in der Entwurfsphase in mehreren Projekten eingesetzt. Ursprünglich
war sie für die Programmierung von Gerätesteuerungen
gedacht, doch sie erwies sich dann als eine für das Programmieren im World Wide Web hervorragend geeignete
Sprache.
1.2.1 DIE ANFÄNGE
Die Programmiersprache Java wurde von einem kleinen
Team unter der Leitung von James Gosling bei SUN Microsystems entwickelt und implementiert.
Das ursprüngliche Java-Team wollte Software für Steuerungselektronik entwickeln. Es musste aber bald feststellen, dass die existierenden Programmiersprachen wie C
und C++ dafür nicht geeignet waren, da diese für einen
bestimmten Computerchip kompiliert werden müssen.
Kommt ein neuer Chip auf den Markt, so können seine
Leistungsmerkmale nur dann voll genutzt werden, wenn
der grösste Teil der Software neu kompiliert wird.
Ein anderes Problem, das die Benutzung traditioneller Programmiersprachen für Steuerungssoftware mit sich bringt,
besteht darin, dass die Geräte gewöhnlich eine lange
Lebensdauer haben. Für Software hingegen ist eine viel
kürzere Lebensdauer charakteristisch. Daraus ergeben
sich zum Teil erhebliche Probleme bezüglich der Rückwärtskompatibilität.
Zudem muss die in der Steuerungselektronik eingesetzte
Software sehr zuverlässig sein, viel zuverlässiger als die
meiste Computersoftware.
James Gosling
begann 1990
1990 begann James Gosling mit der Arbeit an einer Programmiersprache, die für die Steuerungselektronik geeigneter sein und gleichzeitig die mit den traditionellen Sprachen wie C und C++ verbundenen Probleme umgehen
soll.
Das Ergebnis ist Java, eine zuverlässige Sprache, die mit
wenigen Befehlen auskommt und für die verschiedensten
Computerchips verwendet werden kann.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
1 Einführung
10
1.2.2 DAS GREEN-PROJEKT
Das erste Projekt, bei welchem Java eingesetzt wurde,
war das Green-Projekt. Dabei ging es um eine neue Form
von Benutzeroberfläche für die Steuerung von Geräten im
häuslichen Alltag (Videorecorder, Fernseher, Lampen,
Telephon etc.). Die am Green-Projekt beteiligten Mitarbeiter bauten einen experimentellen, tragbaren Computer,
der den Codename *7 („star seven“) erhielt.
Die Benutzeroberfläche bestand aus einer farbigen, animierten Darstellung der häuslichen Umgebung, bei der
verschiedene Geräte durch Berühren des Bildschirmes
bedient werden konnten.
animierte Figur
„Duke“
Zur Bedienung des Gerätes verwendete die Benutzeroberfläche des *7 animierte Figuren auf dem Bildschirm.
Im Rahmen dieses Projektes entstand auch die Zeichentrickfigur Duke, das heutige Java-Maskottchen.
Dem *7-Projekt folgte ein Video-on -Demand-Demoprogramm. Beide Projekte führten zu experimenteller Software und wurden nicht zu echten Produkten weiterentwickelt. Sie wurden ausschliesslich in Java implementiert
und brachten die Entwicklung der Programmiersprache
Java wesentlich voran.
1.2.3 WEBBROWSER UND HOTJAVA
Ab 1993 entwickelte sich das World Wide Web von einem
auf Text basierenden zu einem stärker graphisch ausgerichtetem Interface, das auf immer grösseres Interesse
stiess.
aus WebRunner
wird HotJava
Dem Java-Entwicklungsteam wurde rasch klar, dass eine
plattformneutrale Sprache wie Java sich für die Programmierung von Web-Anwendungen hervorragend eignet, da Java-Programme auf allen verschiedenen Computertypen laufen, die ans Internet angeschlossen sind.
Das Ergebnis dieser Erkenntnis war ein WebRunner genannter Web-Browser, der vollständig in Java geschrieben
war. Aus urheberrechtlichen Gründen wurde dieser Browser später in HotJava umgetauft.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
1 Einführung
11
Java gerät ins
Rampenlicht
HotJava war der erste Web-Browser, der Java-Applets
unterstützte und gleichzeitig ein wichtiger Schritt bei der
Entwicklung der Programmiersprache Java. Er brachte sie
aber nicht nur voran, sondern auch ins Rampenlicht des
öffentlichen Interesses. Andere Programmierer sahen, was
das Java-Team mit HotJava alles bewerkstelligte und
wollten diese Technologie auch in ihrer Software benutzen.
Boom mit
Netscape 2.0
Im Mai 1995 stellte SUN Microsystems die Java-Technologie in San Francisco offiziell vor. Die Tatsache, dass der
populäre Web-Browser Netscape Navigator 2.0, der Ende
1995 auf den Markt kam, Java-Applets unterstützte, heizte
das ohnehin schon grosse Interesse an Java noch zusätzlich an.
1.2.4 WAS BEDEUTET JAVA ?
Ursprünglich hatte James Gosling der Programmiersprache Java den Namen „Oak“ gegeben, wozu ihn eine
grosse Eiche (engl. oak) vor seinem Bürofenster bei SUN
Microsystems inspirierte. Später stellte sich jedoch heraus,
dass eine früher entwickelte Programmiersprache bereits
diesen Namen trug.
einfach Kaffee
Nach vielen Stunden harter Denkarbeit entschloss sich
das Team eines Tages an einem Tisch im Stammcafé für
den Namen „Java“. Java hat ausser „Kaffee“ keine Bedeutung; es ist also kein Akronym, obwohl sich die Auffassung verbreitete, Java stehe für „Just Another Vague
Acronym“ („Noch so eine nichtssagende Abkürzung“).
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
12
1 Einführung
1.3 Die wichtigsten Eigenschaften
höhere Programmiersprache
Java ist - wie C, C++, Pascal und Modula 3 - eine sogenannte höhere Programmiersprache. Java ist unkompliziert, objektorientiert, architekturneutral, multithreaded,
robust, schnell, sicher und erweiterungsfähig. Java-Programme sind schon kompiliert und Java besitzt seine eigene „Müllabfuhr“ (Garbage Collector) sowie statische
Objekttypen; Java kommt mit relativ wenigen Befehlen
aus, und seine Technologie ist schon gut erforscht.
1.3.1 JAVA IST EINFACH UND UNKOMPLIZIERT
nur unverzichtbares übernommen
Java ist C++ sehr ähnlich, aber um einiges einfacher. Alle
Merkmale, die nicht wirklich unverzichtbar sind, wurden
weggelassen. So gibt es bei Java zum Beispiel weder das
Überladen von Operatoren noch Header-Dateien, weder
Präprozessor noch Zeigerarithmetik, Strukturen, Unions
oder eine implizite Typenumwandlung.
Java lässt sich viel einfacher erlernen als C++, da es unkomplizierter im Aufbau ist. Wer schon Kenntnisse in C,
C++ oder Pascal besitzt, wird sich relativ schnell in Java
einarbeiten können.
1.3.2 JAVA IST OBJEKTORIENTIERT
Java ist vollständig objektorientiert; abgesehen von den
einfachen Datentypen wie Zahlen und logischen Ausdrücken, sind die meisten Dinge in Java Objekte.
Der Java-Code ist nach Klassen organisiert; jede Klasse
definiert eine Anzahl von Methoden, die das Verhalten
eines Objektes bestimmen. Zudem kann eine Klasse Eigenschaften von einer anderen Klasse erben.
Klassenhierarchie
mit Einzelvererbung
Java unterstützt eine Klassenhierarchie mit Einzelvererbung, deren Wurzel die Klasse „Objekt“ bildet. Das bedeutet, dass die Klassen jeweils nur von einer einzigen anderen Klasse erben können. Andere Sprachen erlauben
zum Teil auch mehrfache Vererbung; dies kann jedoch zu
Verwirrungen führen und die Sprache unnötig kompliziert
werden lassen.
Wie bereits erwähnt, ist auch in Java nicht alles Objekte.
Um die Programmiersprache so einfach wie möglich zu
machen, sind einfache Typen wie Zahlen und logische
Ausdrücke nicht als Objekte implementiert, Java stellt jedoch gekapselte Objekte zur Verfügung, sodass auch
diese einfachen Typen als Klassen implementiert werden
können.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
1 Einführung
13
Zudem unterstützt Java auch Schnittstellen, die eigentlich
abstrakte Klassen darstellen. Dies ermöglicht es dem Programmierer, Methoden für Schnittstellen zu definieren,
ohne sich gleich Gedanken machen zu müssen, wie diese Methoden schliesslich implementiert werden.
mehrere Schnittstellen als Ersatz
für Mehrfachvererbung
Eine Klasse kann mehrere Schnittstellen implementieren,
so dass viele Vorteile der Mehrfachvererbung erhalten
bleiben, während ein Grossteil der damit verbundenen
Probleme wegfällt. Zusätzlich kann ein Objekt beliebig
viele Schnittstellen implementieren.
In Java-Programmen muss der Typ der benutzten Daten
definiert werden wie es bei vielen traditionellen Programmiersprachen ebenfalls üblich ist. Damit werden
mögliche Fehler aufgrund falscher Datentypen bereits zur
Kompilationszeit erkannt.
Andererseits haben aber alle Objekte in einem Java-System auch einen dynamischen Typen. Es ist jederzeit möglich, auf den dynamische Typen eines Objektes zuzugreifen. Der Programmierer hat also die Möglichkeit, Programme zu schreiben, die für Objekte unterschiedlichen
Typs verschieden reagieren können.
Da das Überprüfen der Typen grösstenteils bei der Kompilierung erfolgt, muss der Interpreter weniger Arbeit leisten
bei der Ausführung eines Programmes. Zur Laufzeit des
Programmes sind nur noch wenige Überprüfungen erforderlich wie zum Beispiel die Prüfung von Array-Grenzen.
1.3.3 JAVA IST ROBUST
Die mehr oder weniger häufig auftretenden Computerabstürze infolge von Programmfehlern sollen mit Java verunmöglicht werden. Das Java-System überprüft jeden
Zugriff auf den Speicher daraufhin, ob er legal ist und keine Probleme verursacht.
Zugriffsschutz
verbessert
In den traditionellen Programmiersprachen hat ein Programm Zugang auf den gesamten Speicherbereich des
Computers. Solche Programme können „unbeabsichtigt“
jeden Wert im Speicher ändern, was häufig zu Problemen
und Abstürzen führt. Java-Programme hingegen haben
nur zu genau definierten Stellen im Speicher Zugang und
können somit keine Werte ändern, die sie nicht ändern
dürfen.
Natürlich können auch bei Java-Programmen Fehler auftreten. Bei unerwarteten Ereignissen stürzt ein Programm
aber nicht einfach ab, sondern es arbeitet eine Ausnahmeroutine ab und befasst sich mit diesen Ereignissen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
14
1 Einführung
1.3.4 JAVA IST SICHER
Java-Programme verfügen über keine Pointer (Zeiger),
was eine vollständigere Verifizierung des Java-Codes vor
der Ausführung ermöglicht. Die so verifizierten Java-Programme bieten damit Gewähr, dass die Regeln der Sprache eingehalten werden und die Programme sicher ausgeführt werden können. Die Verifizierung des Bytecodes
wird auch von den Web-Browsern benutzt, um sicherzustellen, dass die Applets keine Viren enthalten.
keine unerlaubten
Zugriffe auf
Systemdaten
Java wurde für den Einsatz im Internet entwickelt, wo der
Anwender seinen Rechner nicht blindlings einem unbekannten Programmierer anvertrauen möchte. Java erlaubt daher keine unkontrollierten Zugriffe auf Systemdateien oder auf Speicherbereiche. Auch die Kommunikation mit fremden Hosts kann beschränkt und überwacht
werden. Es sollte daher recht schwierig sein, ein „Trojanisches Pferd“ in Java zu schreiben.
1.3.5 JAVA IST PARALLELISIERBAR, MULTITHREADED
Ein modernes Betriebssystem muss heute in der Lage sein,
mehrere Aufgaben quasi gleichzeitig durchführen zu können. Java hat diese Multitasking-Fähigkeit in die Sprache
integriert.
mehrere Threads
gleichzeitig
Java-Programme haben die Möglichkeit, mehrere
Threads ausführen zu können. Ein Java-Programm ist also
in der Lage, eine aufwendige Berechnung durchzuführen
während ein anderer Thread gleichzeitig in Interaktion mit
dem Benutzer tritt. Die Benutzerinteraktion muss also nicht
das Ende der Berechnung abwarten.
Das Programmieren in einer Multithreading-Umgebung
erfordert jedoch erhöhte Aufmerksamkeit, da die Threads
in einer unvorhergesehenen Reihenfolge ausgeführte
werden können. Um unerwünschte Effekte beim Zugriff
auf bestimmte Datenbereiche zu verhindern, bietet Java
die dazu nötigen Synchronisationsmechanismen an.
1.3.6 JAVA-PROGRAMME SIND SCHON KOMPILIERT
Java-Code wird
zu Bytecode
Um ein lauffähiges Java-Programm zu erhalten muss zuerst der Java-Code in sogenannten Bytecode kompiliert
werden. Dieser Bytecode ähnelt Maschinenbefehlen,
welcher jedoch nicht für eine bestimmte Maschine spezifisch ist. Somit können Java-Programme auf den verschiedensten Computern laufen, ohne erneut kompiliert
werden zu müssen.
Der Java-Sourcecode wird zu Dateien vom Typ „class“
kompiliert, welche das Programm in Bytecode enthalten.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
1 Einführung
15
Die class-Dateien enthalten nun Verweise auf Methoden
und Instanzvariablen über einen Namen und werden umgesetzt, sobald der Code erstmals ausgeführt wird. Dies
macht den Code allgemeingültiger und weniger anfällig
für Änderungen ohne Einbussen an dessen Leistungsfähigkeit.
1.3.7 JAVA IST PLATTFORMUNABHÄNGIG
Da Java-Programme bereits in Bytecodes kompiliert sind,
können sie auf jeder Plattform laufen, die Java unterstützt;
d.h. überall wo der Java-Interpreter läuft, kann der Bytecode ausgeführt werden. Um ein Java-Programm auf einem anderen Computer laufen zu lassen, braucht er also
nicht erneut kompiliert zu werden.
auf jeder Plattform
identisch
Die Programmiersprache Java ist auf jeder Plattform identisch. So variieren z.B. die einfachen Datentypen nicht:
Integer-Zahlen umfassen stets 32 Bits, Long Integers 64 Bits.
Bei den Programmiersprachen C und C++ ist dies nicht
der Fall, womit die Übertragung von Programmen auf ein
anderes System ziemlich aufwendig sein kann. Das Übertragen von Java-Programmen hingegen ist einfach, und
es ist nicht notwendig, diese erneut zu kompilieren.
Ausserdem bietet Java eine umfangreiche Bibliothek von
Klassen an, die Zugang zu dem zugrundeliegenden Betriebssystem gewährt. Werden diese Bibliotheken benutzt,
so funktionieren Java-Programme auf jeder Plattform, die
Java unterstützt.
1.3.8 JAVA IST ERWEITERUNGSFÄHIG
Java-Programme können mit existierenden, in anderen
Sprachen geschriebenen Softwarebibliotheken verbunden werden. Da die Datenstrukturen von Java denen von
C sehr ähnlich sind, ist dies relativ einfach. Das grösste
Problem liegt darin, dass die meisten existierenden Bibliotheken nicht multithreaded sind.
Erweiterung mit
nativen Methoden
Java-Programme bieten die Möglichkeit, bestimmte Methoden als „native“ zu deklarieren. Diese nativen Methoden werden dann mit Funktionen verknüpft, die mit der
virtuellen Umgebung dynamisch verbundenen Softwarebibliotheken definiert sind. Obwohl im Prinzip jede Bibliothek mit nativer Software verbunden sein kann, ist dies
nicht immer erlaubt. Aus Sicherheitsgründen wird diese
Möglichkeit für Software, die über das Netzwerk geladen
werden (wie z.B. Applets), gewöhnlich ausgeschaltet.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
1 Einführung
16
1.3.9 JAVA IST GUT ERFORSCHT
Kombination von
bestehenden
Technologien
Die meisten Eigenschaften von Java sind nicht grundsätzlich neu. Sie wurden von anderen Sprachen wie Lisp,
Smalltalk, Pascal, Cedar, Objective-C, Self oder Beta
übernommen. Damit ist Java eigentlich nichts anderes als
eine gute Kombination von bereits existierenden Technologien.
Dies bedeutet aber auch, dass die in Java integrierte
Technologie relativ gut erforscht ist, obwohl die Sprache
neu ist.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
17
2 Java und das Internet
2 Java und das Internet
Das Internet ist ein riesiges, weltweites Netzwerk, das Tausende von Computer unterschiedlichster Art miteinander
verbindet. Für die Kommunikation in diesem heterogenen
Netz ist ein standardisiertes Protokoll wie z.B. TCP/IP nötig.
Das heterogene Internet
Bytecode wird
heruntergeladen
Da Java-Programme als Bytecodes übermittelt werden,
können sie vom Internet auf jeden Computer heruntergeladen und ausgeführt werden, ohne dass der Benutzer
sich Gedanken darüber machen müsste, auf welchem
System das Programm entwickelt wurde.
Bei traditionellen Programmen wäre dies undenkbar. Bei
Sprachen wie C und C++ kann ein Programm nur auf verschiedenen Plattformen laufen, wenn der Source-Code
vorhanden ist und neu kompiliert worden ist. Jeder Benutzer müsste also zunächst das Programm kompilieren, bevor er es laufen lassen kann.
2.1 Die Java-Applets
Die zur Zeit häufigste Art von Java-Programmen bilden die
Java-Applets. Diese meist kleinen Java-Programme sind in
Web-Seiten eingebettet, um dort spezielle Effekte zu er-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
2 Java und das Internet
18
zeugen oder ganz einfach das Interesse des Benutzers zu
wecken.
Die Java-Applets werden auf den Computer heruntergeladen und automatisch ausgeführt, wenn der benutzte
Web-Browser Java unterstützt.
2.2 Sicherheitsaspekte
Prüfung auf
Schutzverletzungen
Da die Java-Programme in Bytecode-Anweisungen kompiliert werden und in dieser Form verifiziert werden können, sind die Java-Applets recht sicher. Die Anweisungen
in Bytecode sind nicht für einen bestimmten Computertyp
spezifisch und können daher auf eventuelle Schutzverletzungen geprüft werden. Dies ist möglich, da die
Bytecodes zusätzliche Informationen über Typen enthalten, die zur Überprüfung der Zulässigkeit des Programms
dienen.
Die meisten Programme für PCs rufen Funktionen über
eine Adresse auf. Da die Adresse lediglich aus einer Zahl
besteht und diese Zahl so konstruiert werden kann, wie es
dem Programmierer gefällt, kann das Programm für die
Ausführung einer Funktion jede beliebige Zahl verwenden.
Dadurch kann man nicht vorhersehen, welche Funktionen
benutzt werden, wenn das Programm aufgerufen wird.
Zugriff erfolgt über
Namen
Java arbeitet auf eine völlig andere Art; der Zugriff auf
Methoden und Variablen erfolgt stets über den Namen.
So kann man einfach feststellen, welche Methoden und
Funktionen tatsächlich benutzt werden. Dieser Prozess
wird als Verifizierung bezeichnet. Er ist notwendig, um sicherzustellen, dass nicht unbefugt an den Bytecodes her-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
2 Java und das Internet
19
umgebastelt wurde und dass sie die Regeln von Java befolgen.
2.2.1 DIE VERIFIZIERUNG
Nach der Verifizierung werden die Applets in einer beschränkten Umgebung ausgeführt, in welcher sie bestimmte gefährliche Funktionen nur ausführen können,
wenn es ihnen ausdrücklich gestattet ist. Aufgrund des
Verifizierungsprozesses können sie aus dieser beschränkten Umgebung nicht ausbrechen.
Computer mit Quellprogramm
Java-Programm
Byte-Codes
Kompilierung
Internet
lokaler Computer
Verifizierung
Byte-Codes
Ausfuehrung
Der Verifizierungsprozess
Wenn die Bytecodes verifiziert worden sind, kann der Interpreter die Funktionsnamen wie traditionelle Programme in Adressen umwandeln; dadurch sind JavaProgramme gleichzeitig leistungsfähig und sicher.
2.2.2 ZUGRIFFSMÖGLICHKEITEN
Die Gestaltung der Zugriffsmöglichkeiten für externe
Applets lassen sich in den Java-fähigen Web-Browsern
einstellen. Dabei kann es folgende Möglichkeiten geben
(dies variiert zwischen den Browsern):
None:
Die Applets haben keinen Zugriff auf das
Netzwerk. Dies ist der beste Schutz, jedoch
sind in diesem Modus nicht alle Applets
lauffähig.
Applet Host:
Hier haben die Applets nur Zugriff auf den
Host, von dem sie stammen. Diese Applets
können daher nicht auf die Informationen
auf ihren Computern zugreifen. Dies ist
auch die Standardeinstellung in der die
meisten Applets ablauffähig sind.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
2 Java und das Internet
Firewall:
20
Applets außerhalb der Firewall können nur
auf Hosts, die ebenfalls außerhalb der Firewall sind, zugreifen. Dieser Modus ist natürlich nur möglich, wenn auch eine Firewall
eingerichtet wurde.
Unrestricted: Hier können Applets zu allen Hosts im Internet Verbindungen herstellen. Dieser Modus
sollte allerdings nur benutzt werden, wenn
keine Sicherheitsbedenken bezüglich des
Applets vorhanden sind.
2.3 Die virtuelle Maschine
Virtuelle Maschine
interpretiert Bytecode
Die Virtuelle Maschine interpretiert den Java Bytecode.
Erst sie löst externe Referenzen auf, indem sie den ClassLoader, der die benötigte Klasse bei Bedarf sucht und in
den Hauptspeicher lädt, aufruft und die Klartextnamen
durch Adressreferenzen ersetzt.
Auf einem Computer bzw. Betriebssystem auf dem diese
Virtuelle Maschine realisiert ist können alle Java Programme laufen. Dabei ist keine Neucompilierung des Quelltextes nötig. Vor der Instanziierung einer Klasse werden dabei
Laufzeitprüfungen und eine Verifikation vorgenommen,
welche die Sicherheit des Programms gewährleisten sollen.
2.4 Applets und Anwendungen
Java-Programme können in Zwei Hauptgruppen aufgeteilt werden: Applets und Anwendungen
2.4.1 APPLETS
Applets sind Java-Programme, die über das World Wide
Web heruntergeladen werden und von einem WebBrowser auf der Maschine des Benutzers ausgeführt werden. Applets können nur von einem Java-fähigen Browser
ausgeführt werden bzw. mit dem Applet Viewer aus dem
Java Development Kit (JDK).
2.4.2 ANWENDUNGEN
Java-Anwendungen sind allgemeinere, in der Sprache
Java geschriebene Programme. Zum Ausführen von Java-Anwendungen ist kein Browser nötig.
Eine Java-Anwendung enthält eine Klasse, welche eine
main()-Methode definiert.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
2 Java und das Internet
21
2.5 JavaScript
JavaScript ist ein Gemeinschaftswerk von SUN und Netscape und ist noch kein Standard, sondern befindet sich
noch im Entwicklungsstadium. Zwar kann der NetscapeBrowser ab Version 2.0 JavaScript-Programme abarbeiten, der Umfang der Script-Sprache wird jedoch noch
ständig erweitert.
Der Name JavaScript legt eine Verwandtschaft zwischen
der Script-Sprache und der objektorientierten Programmiersprache Java nahe. Trotz einigen Gemeinsamkeiten
unterscheiden sich beide in wesentlichen Punkten voneinander:
Interpretation erfolgt zur Laufzeit
- JavaScript wird durch den Web-Browser auf dem ClientRechner interpretiert. Der Programm-Quelltext wird also
nicht kompiliert.
- JavaScript ist objektbasiert, erlaubt jedoch keine Klassendefinitionen oder Vererbung. Die Objekte werden
durch den Browser verwaltet.
- „dynamic binding“: Objektreferenzen werden bei JavaScript erst zur Laufzeit aufgelöst. Wird eine Funktion verwendet, die nicht definiert wurde, meldet der Browser
erst dann einen Fehler, wenn diese tatsächlich aufgerufen wird.
- Variablen müssen bei JavaScript nicht explizit deklariert
werden.
- JavaScript ist langsamer als Java, da das Programm erst
zur Laufzeit interpretiert wird.
- der Quelltext eines JavaScript-Programms ist vollständig
in der HTML-Seite enthalten.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
22
3 Die Sprache Java
3 Die Sprache Java
ähnlich wie CSyntax
Wer bereits über Erfahrung mit der Programmiersprache C
verfügt, sollte keine Probleme haben, sich mit Java zurechtzufinden. Java benutzt, wo immer es möglich ist, die
C-Syntax, da diese vielen Programmierern vertraut ist.
Erfahrungen in objektorientierten Programmiersprachen
sind zwar von Vorteil, aber nicht Bedingung, um sich mit
Java zurechtzufinden. Das Klassenkonzept von Java ähnelt zwar jenem von C++, ist aber wesentlich einfacher
und konsequenter umgesetzt worden.
3.1 Unterschiede zu C/C++
Die Entwickler von Java haben sich Mühe gegeben, die
Sprache auf die wichtigsten Befehle und Möglichkeiten zu
beschränken. Dies hat zur Folge, dass einige Möglichkeiten von C bzw. C++ weggelassen wurden, was aber
durchaus zu einem Vorteil werden kann. (siehe auch Anhang C Unterschiede C++ / Java)
3.1.1 KEINE HEADER FILES UND PRECOMPILER
Header-Files
unnötig
In Java werden die Klassen komplett in einem File codiert;
Header Files wie in C werden nicht mehr benötigt. Zu jeder Klasse wird ein eigenes .class-File erzeugt. Dadurch
kann es z.B. nicht mehr vorkommen, dass durch Änderungen in einer zentralen Klasse in einem Header File das gesamte Projekt neu übersetzt werden muss. Der Einsatz von
Java macht Hilfsmittel wie „make“ und trickreiche Compilerfeatures unnötig, die versuchen dieses Problem zu
minimieren.
Ebenso werden Precompiler (z.B. # DEFINE) bei Java nicht
eingesetzt. Der durchgängig objektorientierte Ansatz soll
einen Precompiler unnötig machen. Globale Definitionen
von Konstanten können als Klassenvariablen (static) realisiert werden. Dadurch bekommen die Konstanten auch
einen eigenen Namensraum, was widersprüchliche Bezeichnernamen ausschliesst. Somit werden auch diverse
Tricks und Fehlerquellen ausgeschlossen.
3.1.2 KEINE STRUKTUREN UND UNIONS
Die Aufzählungstypen (z.B. enum), Strukturen und Unions
können in Java (wie in jeder objektorientierten Program-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
23
3 Die Sprache Java
miersprache) durch geeignete Klassen dargestellt werden
In C++ ist dieser „Ballast“ nur vorhanden, um die gewünschte Kompatibilität zu C zu gewährleisten.
3.1.3 KEINE FUNKTIONEN
alleinstehende
Funktionen unnötig
Alleinstehende Funktionen, die nicht Methoden einer Klasse sind, werden in Java nicht unterstützt. Dies vermeidet
Mehrdeutigkeiten und Widersprüche in der Klassenhierarchie. Java unterstützt Klassenmethoden und Klassenvariablen, wodurch alleinstehende Funktionen unnötig
werden.
3.1.4 KEINE MEHRFACHVERERBUNG
Die gewaltigen Probleme, die durch den Einsatz von
Mehrfachvererbung auftreten können, sind in Java dadurch umgangen worden, dass Java diese Möglichkeit
gar nicht zur Verfügung stellt.
mehrfache
Interfaces
Durch den Einsatz von Interfaces, die einen Satz von
Schnittstellenmethoden definieren, die in einer Klasse implementiert werden, wird eine weitgehend vergleichbare
Funktionalität ohne die bekannten Probleme erreicht. Diese Interfaces wurden den „protocols“ in Objective C
nachempfunden.
3.1.5 KEINE GOTO-BEFEHLE
„Goto“ gehört zwar auch bei Java zu den reservierten
Wörtern, wird aber als Befehl nicht mehr unterstützt. Der
goto-Befehl wird sehr häufig missbraucht nur aus der Tatsache, dass der Befehl unterstützt wird.
Die meisten goto-Befehle lassen sich ohne Probleme
durch mehrstufige break- und continue-Befehle ersetzen.
3.1.6 KEIN ÜBERLADEN VON OPERATOREN
kein Operator
Overloading
Java unterstützt kein Operator Overloading. Zum einen
war diese Möglichkeit schon immer umstritten, und zum
anderen hat SUN bei der Entwicklung der Sprache der
Einfachheit und Klarheit den Vorrang gegeben. Die Möglichkeit des Operator Overloading kann übrigens durch
Klassenmethoden einfach ersetzt werden.
3.1.7 KEINE AUTOMATISCHE TYPENUMWANDLUNG
Bei Java findet keine automatische Typenumwandlung
von einem Datentypen in den anderen statt. Jede zulässige Typenumwandlung muss implizit programmiert werden.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
24
3 Die Sprache Java
3.1.8 KEINE POINTER UND POINTERARITHMETIK
keine Pointer
Java hat zum Ziel, eine möglichst sichere Laufzeitumgebung zur Verfügung zu stellen. Aufgrund der Möglichkeit,
komplexe Strukturen mit Hilfe von Klassenhierarchien darzustellen, ist Java nicht auf Pointerarithmetik angewiesen.
In Java gibt es generell keine expliziten Pointer, womit ein
weiterer Grossteil der Fehlermöglichkeiten herkömmlicher
C- und C++-Programme ausgeschlossen werden.
3.1.9 KEINE VAGE DEFINIERTEN DATENTYPEN
vollständig definierte Datentypen
In Java sind die primitiven Datentypen, anders als in C
vollständig definiert. So ist ein int immer 32 Bit breit und mit
Vorzeichen behaftet. Es gibt anders als in C feste Definitionen für die Basis-Datentypen, die übrigens die einzigen
Typen sind, die keine Klasse darstellen. Durch Vererbung
können ihnen jedoch weitere Methoden zugeordnet werden.
Die direkte Implementierung von Basis-Datentypen in die
Programmiersprache verbessern das Laufzeitverhalten
gegenüber typenlosen Programmiersprachen wie zum
Beispiel Smalltalk, enorm.
3.1.10 KEINE FREIE ARGUMENTENANZAHL (VARGS)
Java unterstützt keine Funktionen mit variabler Argumentenanzahl wie es z.B. in C bei der Funktion printf verwendet wird.
Auch hier stellt der objektorientierte Ansatz geeignetere
und weniger fehlerträchtige Möglichkeiten zur Verfügung
(wie es schon in C++ mit cout realisiert wird).
3.1.11 KEINE SEMIKOLON ?
Beim Design von Java wurde darauf geachtet, daß der
Programmierer nicht mit irgendwelchen “; erwartet” Fehlermeldungen zu kämpfen hat. Wo es die Grammatik erlaubt, ist der “;” optional oder kann beliebig oft gesetzt
werden.
bessere Lokalisierung von Fehlern
Bei der Entwicklung der Sprache wurde auch darauf geachtet, dass der Compiler die Möglichkeit hat, Fehler genau zu lokalisieren. Die in C übliche Fehlermeldung mit
Verweis auf eine Zeile die auf die eigentlich fehlerhafte
Zeile mit fehlendem Semikolon folgt, sollte in Java nicht
vorkommen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
25
3 Die Sprache Java
3.2 Überblick über die Syntax
Die Syntax von Java ist derjenigen von C sehr ähnlich.
Wer bereits mit C oder C++ vertraut ist, kann einfach auf
diesen Kenntnissen aufbauen.
3.2.1 KOMMENTARE
neuer Dok-Kommentar
Java kombiniert die kommentierte Syntax von C und C++.
Seine Syntax erlaubt es ausserdem, automatisch formatierte Dokumentationen zu erstellen:
/* wie in C: Kommentare bis zu einem definierten Ende */
// Kommentar wie in C++: bis zum Zeilenende
/** „doc“-Kommentar: kann zum Erzeugen von Dokumentationen benutzt werden, darf aber nur vor einer Deklaration gesetzt werden */
3.2.2 EINFACHE DATENTYPEN
Ausser den hier vorgestellten Grundtypen, besteht Java
praktisch nur aus Objekten. Aber auch die Grundtypen
können, falls dies gewünscht wird, als Klassenobjekte implementiert werden.
Von wenigen Ausnahmen abgesehen hat Java die
Grundtypen von C und C++ übernommen. Es gibt in Java
drei Gruppen von einfachen Datentypen:
3.2.2.1 Numerische Datentypen
numerische Typen
mit Vorzeichen
Ganzzahlige Typen:
byte
short
int
long
8 Bit
16 Bit
32 Bit
64 Bit
Fliesskommazahlen:
float
double
32 Bit
64 Bit
Alle numerischen Datentypen sind in Java vorzeichenbehaftet.
3.2.2.2 Charakter Datentyp
16 Bit-Unicode
Der Charakter-Datentyp char definiert einen 16 Bit-Unicode Charakter. In Java ist dieser nicht mit einem Vorzeichen behaftet.
3.2.2.3 Logischer Datentyp (Boolean)
echter Boolean
In Java besteht ein boolean aus einem „echten“ 1 Bit
Wert. Dieser Datentyp kann im Gegensatz zu anderen
Programmiersprachen nicht in einen numerischen Datentypen konvertiert werden.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
26
3.2.3 REFERENZIERENDE DATENTYPEN
Zuweisung by reference
Die referenzierenden Datentypen haben ihren Namen
erhalten weil sie auf Objekte oder Arrays „by reference“
verweisen, d.h. die Adressen des Objekts bzw. Arrays in
einer Variablen speichern. Im Gegensatz dazu speichern
die einfachen Datentypen die aktuellen Werte in einer
Variable; diese Zuweisung wird als Referenz „by value“
bezeichnet.
Die Zuweisung der einfachen Datentypen erfolgt immer
„by value“; bei Arrays und Objekten hingegen erfolgt die
Zuweisung immer „by reference“.
3.2.3.1 Zuweisung von Objekten
Da referenzierende Typen nicht „by value“ übergeben
werden, kopiert die Übertragung von einem Objekt zu
einem anderen nicht den Wert des Objekts; es weist diesem lediglich eine Referenzierung zu.
Kopieren mit
clone()
Um die Daten eines Objektes in ein anderes Objekt zu kopieren, benutzt man in Java die clone() Methode:
Vektor b = new Vektor;
c = b.clone();
Diese Methode wird allerdings nicht von allen Typen unterstützt. Nur Klassen, welche das Cloneable Interface implementieren, können diese Methode benutzen.
Arrays sind ebenfalls referenzierende Typen und die Zuweisung eines Arrays kopiert einfach die Referenz auf das
Array. Um eine aktuelle Kopie der gespeicherten Werte
des Arrays zu erhalten, muss man jeden einzelnen Wert
zuweisen oder die System.arraycopy() Methode benutzen.
3.2.3.2 Kontrolle von Objekten
identische
Objekte ?
Mit dem == Operator lässt sich prüfen, ob zwei Variablen
dasselbe Objekt referenzieren und nicht, ob die zwei Objekte dieselben Daten enthalten.
Um wirklich zu testen, ob zwei separate Objekte identisch
sind, gibt es in Java eine spezielle Methode. Einige der
Klassen bieten diese Methode equals() an, um diesen Test
durchzuführen.
3.2.3.3 Referenzierung und Dereferenzierung
automatische
Referenzierung
Die Referenzierung und Dereferenzierung von Objekten
geschieht in Java sozusagen automatisch, denn Java
verfügt über keine Pointer und erlaubt keine Manipulation
von Speicheradressen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
27
3.2.3.4 null-Werte
Der Default-Wert für Variablen aller referenzierenden Typen ist null. Null ist ein reservierter Wert, der die „Absenz
einer Referenz“ anzeigt; d.h. dass die Variable kein Objekt
oder Array referenziert.
null ist ein Schlüsselwort
In Java ist null ein reserviertes Schlüsselwort, nicht wie NULL
in C, welches bloss eine Konstante mit dem numerischen
Wert 0 ist. Null ist eine Ausnahme in den strengen Sprachregeln in Java; es kann irgendeinem referenzierenden
Typen zugewiesen werden (z.B. irgendeine Variable, welche über eine Klasse, ein Interface oder Array dieses Typs
verfügt).
„Null“ kann in Java in keinen einfachen Datentypen umgewandelt werden einschliesslich der Typen int und boolean.
3.2.4 OBJEKTE
Nachdem wir gesehen haben, dass Objekte in Java „by
reference“ übergeben werden, fehlt nur noch das Wissen,
wie man diese Objekte kreiert, auf sie zugreift und wieder
beseitigt.
3.2.4.1 Definition von Objekten
Definition mit new
Die Deklaration einer Variablen, um ein Objekt zu erhalten, kreiert dieses Objekt nicht; die Variable enthält nur
die Referenz auf das Objekt. Um wirklich ein Objekt zu definieren, benutzt man das Schlüsselwort new; dieses
Schlüsselwort wird gefolgt von einem Klassenobjekt und
einer optionalen Argumentenliste in Klammern. Diese Argumente passieren die Konstruktor-Methode für diese
Klasse, welche die Initialisierung der internen Datenfelder
in die neuen Objekte übernimmt:
java.awt.Button b = new java.awt.Button();
ComplexNumber c = new ComplexNumber(1.0,1.414);
Es gibt aber auch andere Wege, ein Objekt zu kreieren.
Ein String-Objekt z.B. kann einfach kreiert werden, indem
eine Zeichenkette (in doppelten Hochkommas) einer Variable zugeordnet wird:
String s = „Dies ist ein String“;
Ein anderer Weg ist die newInstance() Methode eines
Klassenobjektes. Diese Methode ist speziell geeignet,
wenn dynamisch geladene Klassen benutzt werden.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
28
3 Die Sprache Java
3.2.4.2 Zugriff auf Objekte
Zugriff mit PunktOperator
Die Syntax für den Zugriff auf Objekte in Java gleicht derjenigen in C für Strukturen; es wird der Punkt-Operator
verwendet:
ComplexNumber c = new ComplexCumber();
c.x = 1.0;
c.y = 1.414;
Da Java auf Objekte immer „by reference“ zugreift und
die Dereferenzierung automatisch vorgenommen wird,
gleicht der Punkt-Zugriff von Java eher dem -> Operator
in C.
3.2.4.3 „löschen“ von Objekten
In Java werden die Objekte mit dem Schlüsselwort new
kreiert, aber es existiert kein Schlüsselwort wie delete, old
oder free.
löschen unnötig
Ein solches Schlüsselwort ist auch nicht nötig, da Java
über eine Technik verfügt, die automatisch erkennt, ob ein
Objekt noch referenziert und weiter benötigt wird. Diese
Technik nennt sich Garbage Collection (Müllabfuhr).
3.2.5 MÜLLABFUHR, „GARBAGE COLLECTOR“
Als erste Besonderheit, insbesondere für nicht Smalltalk
Programmierer ist das Konzept der Speicherverwaltung in
Java zu nennen. In Java gibt es keinen Heap auf dem
dynamische Daten alloziert werden, also auch kein malloc oder mfree. Vielmehr sorgt die Java-Laufzeitumgebung selbst dafür, dass nicht mehr benötigte Objekte automatisch freigegeben werden. Dazu trägt jedes Objekt
einen Zähler mit sich, wie viele Verweise auf das Objekt
noch existieren.
Aufräumen im
Hintergrund
Die Arbeit, selbst dafür zu sorgen, dass Objekte rechtzeitig
freigegeben werden, die z.B. in C++ bei komplexeren
Programmen extreme Ausmaße annimmt, entfällt also
völlig. Man spricht von einem Garbage Collector. In Java
läuft dieser Garbage Collector in einem eigenen Task mit
niederer Priorität, das Aufräumen wird also im Hintergrund
erledigt.
keine Speicherleichen mehr
Speicherleichen, also Objekte die nicht mehr benötigt
werden, deren Speicher jedoch nicht freigegeben wurde,
gehören automatisch der Vergangenheit an. Es kann
auch nicht mehr vorkommen, dass eine Referenz auf ein
nicht mehr alloziertes Objekt existiert, was bei C und C++
zu häufigen Fehlern geführt hat (z.B. eine durch eine lokale Funktion deklarierte Variable wird per Pointer dem
Aufrufer bekanntgegeben).
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
29
3 Die Sprache Java
Dieses Konzept tritt nicht nur auf Objekte sondern auch für
Klassen in Kraft, da Klassen in Java nichts anderes sind als
von der Klasse Objekt abgeleitete Objekte. Das heißt insbesondere, dass zur Laufzeit eines Programms nur die
Klassen im Hauptspeicher gehalten werden, die auch
wirklich gebraucht werden. Das hat zur Folge, dass beim
Programmstart zunächst nur die Basisklassen geladen werden, was allerdings auf Grund des dynamischen Linkvorgangs, der gleichzeitig einsetzt, merklich Zeit in Anspruch
nimmt.
3.2.6 ARRAYS
Unterstützung und Syntax für Arrays in Java sind denen in
C sehr ähnlich. In Java dürfen Arrays jedoch nicht dem
Stack (Stapelspeicher) zugewiesen werden; sie müssen
also dynamisch zugewiesen werden.
3.2.6.1 Erzeugen und löschen von Arrays
Es existieren zwei Arten der Definition von Arrays:
Zum einen kann dies mit dem Schlüsselwort new erfolgen:
byte ZeichenBuffer[] = new byte[1024];
Button buttons[] = new Button[10];
Initialisierung mit
Default-Werten
Die Elemente, der auf diese Art kreierten Arrays werden
mit den Default-Werten ihres Typs initialisiert. Elemente des
Typs int sind auf den Wert 0 initialisiert und Elemente des
Typs object sind auf null initialisiert.
Zum anderen kann ein Array ebenso kreiert werden, wie
wir es von C auch kennen, durch direkte Initialisierung:
int Tabelle[] = {1,2,4,8,16,32,64,128};
Diese Syntax erzeugt dynamisch einen Array und initialisiert diesen mit den spezifizierten Werten. Die spezifizierten
Werte können im Gegensatz zu C willkürliche Ausdrücke
sein und müssen nicht aus konstanten Ausdrücken bestehen.
Arrays brauchen wie die Objekte auch nicht gelöscht zu
werden; sie werden automatisch vom Garbage Collector
behandelt.
3.2.6.2 Mehrdimensionale Arrays
Array von Arrays
Wie man es von C kennt, hat auch Java die Möglichkeit
von mehrdimensionalen Arrays als Array von Arrays implementiert.
Um ein mehrdimensionales Array zu definieren, genügt es
, die normale Definition mit der gewünschten Anzahl Felder zu ergänzen:
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
30
3 Die Sprache Java
int Matrix[][] = new int[10][10];
Bei der Definition von mehrdimensionalen Arrays ist es
nicht erforderlich, bei allen Feldern die entsprechende
Anzahl Werte anzugeben . Allerdings muss die Anzahl Felder von mindestens einer Dimension bekannt sein und auf
eine nicht spezifizierte Dimension darf keine spezifizierte
Dimension folgen:
int DreiD_1[][][] = new int[10][][];
int DreiD_2[][][] = new int [10][][5];
// gültig
// ungültig
Mehrdimensionale Arrays können auch bei der Definition
direkt initialisiert werden; zudem ist es nicht nötig, dass sie
rechteckig aufgebaut sind:
int Dreieck[][] = {{1,2},{3,4,5},{5,6,7,8}};
3.2.6.3 Zugriff auf Arrays
Der Zugriff auf Elemente des Arrays geschieht analog wie
in C: gefolgt auf den Namen des Arrays folgt in eckigen
Klammern ein Integer-Wert für das entsprechende Element.
Kontrolle der
Array-Grenzen
In Java wird der Index kontrolliert, was einen Zugriff über
die Array-Grenzen hinaus verunmöglicht. Falls der Index
ausserhalb der Grenzen ist, wird die ArrayIndexOutOfBoundsExceptions Methode durchgeführt.
3.2.7 ZEICHENKETTEN (STRINGS)
In Java sind Strings Sprachobjekte und nicht Pseudo-Arrays von Charakterzeichen wie in C. Es existieren zwei Arten von String-Objekten:
Für konstante Strings, d.h. Strings die nicht verändert werden können, stellt Java die String-Klasse zur Verfügung.
Für Strings, deren Inhalt veränderbar, manipulierbar sein
muss, ist die Klasse StringBuffer zu verwenden.
3.2.8 ARITHMETISCHE UND RELATIONALE
OPERATOREN
Java unterstützt alle Operatoren von Standard C. Diese
Operatoren besitzen auch dieselbe Präzedenz wie in C.
Operator
+
*
/
%
<
>
© J.-P. Thomsen 1996
Bedeutung
Addition
Subtraktion
Multiplikation
Division
Modulus
Kleiner als
Grösser als
28.10.96 15:53
Java - Tutorial
31
3 Die Sprache Java
<=
>=
==
!=
&&
||
!
&
|
^
<<
>>
>>>
∼
=
++
-+=
-=
*=
/=
%=
&=
|=
<<=
>>=
>>>=
Kleiner als oder gleich
Grösser als oder gleich
Gleich
Nicht gleich
Logisches AND
Logischer OR
Logisches NOT
AND
OR
XOR
Verschiebung nach links
Verschiebung nach rechts
Verschiebung nach rechts, Füllnullen
Komplement
Zuweisung
Inkrement
Dekrement
Addition und Zuweisung
Subtraktion und Zuweisung
Multiplikation und Zuweisung
Division und Zuweisung
Modulus und Zuweisung
AND und Zuweisung
OR und Zuweisung
Verschiebung nach links und Zuweisung
Verschiebung nach rechts und Zuweisung
Verschiebung nach rechts, Füllnullen und Zuweisung
Operatoren
Da Java keine Pointermanipulation kennt, können natürlich auch die Referenzierungs- und Dereferenzierungsoperatoren *, & und sizeof nicht unterstützt werden. Ausserdem unterstützt Java weder die Operatoren für Array- ([])
noch für Feldzugriffe (.).
Java kennt dafür ein paar neue Operatoren:
3.2.8.1 Der +-Operator
Verkettung von
Text
Der +-Operator erlaubt die einfache Konkatenierung von
Zeichenketten. Dieser Operator hat dieselbe Präzedenz
wie der arithmetische +-Operator.
3.2.8.2 Der instanceof-Operator
Der instanceof-Operator gibt „true“ zurück, wenn ein Objekt (links vom Operator) eine Instanz der Klasse oder des
Interfaces (rechts vom Operator) ist. Andernfalls liefert
instanceof „false“. Der instanceof-Operator hat dieselbe
Präzedenz wie die Operatoren <, <=, > und >=.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
32
3.2.8.3 Der >>>-Operator
Da die ganzzahligen Datentypen in Java alle vorzeichenbehaftet sind, ist der >>-Operator definiert als ein nach
rechts schieben mit Vorzeichenerweiterung. Der >>>-Operator betrachtet den Zahlenwert als „unsigned“ und
schiebt die Bits nach rechts mit einer Null-Erweiterung.
3.2.8.4 Die Operatoren & und |
&, | wirkt auf
boolean wie logisches AND, OR
Wenn die Operatoren & und | auf integrale Datentypen
angewendet werden, entsprechen sie den bitweisen ORbzw. AND-Anweisungen. Da Java strikte unterscheidet
zwischen Integer- und Boolean-Datentypen, wirkt deren
Anwendung auf den Boolean-Datentyp wie ein logisches
AND bzw. OR.
Bei diesen logischen Operatoren werden immer beide
Operanden ausgewertet auch wenn das Resultat nach
dem ersten Ausdruck bereits feststeht. Diesen Umstand
kann man benutzen, wenn die Operanden Ausdrücke mit
Nebeneffekten (z.B. Methodenaufrufe) sind und immer
beide Operanden ausgewertet werden sollen.
3.2.9 BEFEHLE
Java verfügt über den von C und C++ her bekannten Satz
von Entscheidungsbefehlen für Programmabläufe. Es gibt
ein paar Unterschiede, die im folgenden erläutert werden
sollen.
3.2.9.1 if/else, while, do/while Anweisungen
Prüfausdruck: logischer Wert
Die if, else, do, while Anweisungen sind genau dieselben
wie in C und anderen Programmiersprachen. Der einzige
Unterschied zu C besteht darin, dass der Prüfausdruck in C
einen logischen Wert zurückgeben muss. In Java hingegen darf Null nicht mit der Bedeutung „falsch“ beziehungsweise Nicht-Null nicht mit der Bedeutung „wahr“
benutzt werden.
3.2.9.2 switch Anweisung
Auch die switch-Anweisung entspricht derjenigen von C.
Man kann die Datentypen byte, char, short, int und long
für die case-Anweisung verwenden. Ebenso kann ein default Label verwendet werden:
switch (expression) {
case Konstante1:
/* */
break;
case Konstante2:
/* */
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
33
3 Die Sprache Java
break;
default:
/* */
break;
}
3.2.9.3 for Anweisung
Die for-Schleife ist auch in Java die wahrscheinlich am
häufigsten verwendete Kontrollflussanweisung. Es bestehen zwei Unterschiede zur for-Schleife in C:
komma-separierte
Ausdrücke
Zum ersten unterstützt Java den Komma-Operator von C
nicht, der es erlaubt, mehrere Ausdrücke zu einem einzigen Ausdruck zu verbinden. Die for-Schleife in Java simuliert diese Möglichkeit durch komma-separierte Ausdrükke im Initialisierungs- und Inkrementierungsbereich, nicht
aber im Testbereich:
int i;
String s;
for (i=0, s=„Test“;
// Initialisierung
(i>10) && (s.length() >=1);
// Test
i++, s=s.substring(1))
// Inkrementierung
{
System.out.println(s);
// Schleife
}
Zum zweiten ist es die von C++ übernommene Fähigkeit,
lokale Schleifen-Variablen im Initialisierungsbereich zu deklarieren. Auf diese Art deklarierte Variablen sind jedoch
nur innerhalb der Schleife gültig. Da diese Art der Variablendeklaration ebenfalls das Komma benutzt, erlaubt
Java entweder die Möglichkeit der komma-separierten
Initialisierungsausdrücke oder die Deklaration und Initialisierung mehrerer komma-separierter Variablen desselben
Typs. Diese zwei Möglichkeiten können nicht gemischt
verwendet werden.
3.2.9.4 break,continue Anweisungen
In Java gibt es auch die zwei Entscheidungsbefehle break
und continue, die ein optionales Label haben können.
Ohne das Label haben sie die gleiche Bedeutung wie in
C. Wird jedoch das Label gesetzt, so beginnt die weitere
Verarbeitung mit demjenigen Befehl, der mit dem Label
versehen ist.
ausbrechen aus
einer Schleife
Break-Anweisungen mit einem Label sind vor allem dann
nützlich, wenn eine switch-Anweisung in eine for-Schleife
eingebaut werden soll. Die break-Anweisung hat nämlich
in einer switch-Konstruktion eine besondere Bedeutung:
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
34
3 Die Sprache Java
das Hinzufügen eines Labels ermöglicht es, aus einer
switch-Anweisung in einer Schleife auszubrechen
loopStart:
for (int j=0; j<10; j++) {
/* break springt hierhin */
switch (j) {
case 4:
break;
default:
if (j%2) == 0)
break loopStart;
break;
}
}
// springt in die Schleife
3.2.9.5 synchronized Anweisung
Die synchronized Anweisung dient der Synchronisierung in
der Multithreaded-Umgebung von Java. Sie sperrt das
Objekt beim Aufruf und entsperrt es beim Verlassen. Wenn
das Objekt bereits gesperrt ist, wartet die Methode mit der
Ausführung bis die Sperre aufgehoben ist (siehe auch Kapitel 3.4 Threads).
3.2.9.6 package, import Anweisungen
Packages bieten die Möglichkeit, verwandte Klassen zusammenzugruppieren. Ausgewählte Klassen aus einem
solchen Package können durch den import-Befehl von
Klassen ausserhalb des Packages benutzt werden (siehe
auch Kapitel 3.6 Die Java-Packages).
3.2.10 SCHLÜSSELWORTE
Java kennt bzw. unterstützt die folgenden reservierten
Schlüsselworte:
abstract
case
class
do
final
future
implements
int
new
package
rest
super
throw
var
© J.-P. Thomsen 1996
boolean
cast
const
double
finally
generic
import
interface
null
private
return
switch
throws
void
break
catch
continue
else
float
goto
inner
long
operator
protected
short
synchronized
transient
volatile
byte
char
default
extends
for
if
instanceof
native
outer
public
static
this
try
while
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
35
Schlüsselworte2
Die kursiv geschriebenen Schlüsselworte werden zur Zeit
nicht unterstützt.
3.2.11 SYNCHRONISIERUNG
parallele Ausführung
Java verwendet selbst z.B. zur Realisierung der Speicherverwaltung Threads und es stellt dem Programmierer Klassen und Methoden zur Thread-Bildung zur Verfügung.
Threads ermöglichen das parallele Ausführen einzelner
Programmteile. Bei GUI-basierenden Systemen ist es z.B.
wichtig, dass verschiedene Aufgaben parallel erledigt
werden. So will der Anwender in der Menüstruktur blättern
während in einem Fenster Berechnungen ausgeführt werden und in einem anderen gerade eine Graphik aufgebaut wird.
integrierter Monitor
Bei Java muß sich der Programmierer nicht mehr mit den
Besonderheiten der Zielplattform auseinandersetzen und
er muß auch keine Bedenken haben, ob die StandardLibrary-Funktionen mehrfach gleichzeitig aufgerufen worden sind. Er bekommt durch Java einheitliche Methoden
zur Synchronisation von Threads und zur Kommunikation
zwischen verschiedenen Threads zur Verfügung gestellt.
Durch den Modifizierer synchronized können Methoden
eines Objekts gegen mehrfachen parallelen Aufruf geschützt werden. Ein in der Java-Laufzeitumgebung implementierter Monitor überwacht dann, dass diese Methoden des Objekts nicht parallel sondern seriell ausgeführt werden. Generell sollten alle Methoden, die Objektattribute verändern, als synchronized deklariert werden.
Die Standardbibliothek ist vollständig “threadfest”, d.h.
Methoden können uneingeschränkt mehrfach parallel
aufgerufen werden.
3.3 Ausnahmen (Exceptions + Exception Handling)
In Sprachen wie C werden Laufzeitfehler auf die verschiedensten Arten behandelt. Häufig geschieht dies mit
den verschiedensten Rüchgabewerten bei Funktionen,
welche immer abgefangen und interpretiert werden müssen, sodass die Übersichtlichkeit des Programmcodes
darunter leidet. Java bietet dagegen eine Alternative: die
Ausnahmen (Exceptions).
2
[Nutshell], Seite 181
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
Ausnahmen anstelle von Rückgabe-Codes
36
Mit Ausnahmen können aussergewöhnliche Bedingungen
in einem Programm behandelt werden, sodass der normale Code sauberer und übersichtlicher wird. Im Gegensatz zu den Methoden der Fehlerbehandlung, die
Fehlercodes zurückgeben wie z.B. in C, kann der Aufrufer
der Methode die Ausnahme ignorieren und sie im CallStack hinaufwandern lassen bis sich eine Methode mit ihr
befasst. Unter einem Call-Stack versteht man einfach die
Sequenz der Methodenaufrufe.
3.3.1 AUSNAHME-OBJEKT
Eine Ausnahme in Java ist eigentlich ein Objekt, welches
wiederum eine Instanz der Throwable-Klasse (java.lang.
Throwable) oder einer Unterklasse davon ist.
Da Ausnahmen Objekte sind, können sie auch Daten und
Methoden enthalten. Das Throwable-Objekt an der Wurzel
der Ausnahme-Hierarchie beinhaltet eine String-Meldung,
welche alle Datenfelder an das Ausnahme-Objekt vererbt. Diese Meldung kann nun von der Ausnahme mit der
Throwable.getMessage()-Methode gelesen werden.
3.3.2 BEHANDLUNG VON AUSNAHMEN
Für die Behandlung von Ausnahmen dienen in Java die
Anweisungen try, catch und finally.
3.3.2.1 try
Der try-Anweisung folgt ein Codeblock, der normal
durchlaufen wird. Falls durch eine Anweisung in diesem
Block eine Ausnahme entsteht, werden die Argumentdeklarationen der catch-Anweisung solange geprüft, bis die
Ausnahme einem Argument zugewiesen werden kann.
3.3.2.2 catch
catch-Klauseln
spezifizieren Ausnahmetypen
Dem try-Block folgen zwischen keinem und mehreren
catch-Klauseln, die den Code für die Behandlung von
verschiedenen Ausnahmetypen spezifizieren. Diese catchKlauseln haben eine spezielle Syntax: jede Klausel wird mit
einem Argument deklariert wie ein Methodenargument.
Dieses Argument muss allerdings vom Typ Throwable bzw.
einer Unterklasse davon sein.
Jeder dieser catch-Blöcke bearbeitet einen Ausnahmefall. Wenn eine Ausnahme auftritt, so wird die erste catchKlausel aufgerufen, welche ein Argument vom verwendeten Typ hat. Das catch-Argument ist nur innerhalb des
catch-Blockes gültig und referenziert das aktuelle Objekt,
welches aufgetreten ist.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
37
3.3.2.3 finally
finally-Block wird
immer ausgeführt
Der finally-Block enthält Anweisungen, die auf jeden Fall
ausgeführt werden müssen, egal ob ein Fehler aufgetreten ist oder nicht. An dieser Stelle ist es z.B. sinnvoll, bei IOFunktionen den close-Befehl unterzubringen.
Auch für den Fall, dass der try-Block mit einer return-,
break- oder continue-Anweisung abgebrochen wird,
werden vor dem Fortsetzen des Programms die Anweisungen im finally-Block ausgeführt.
Falls nach dem Auftreten einer Ausnahme kein entsprechender lokaler catch-Block gefunden wird, wird ebenfalls der finally-Block ausgeführt bevor die Ausnahme an
den nächsten nicht-lokalen catch-Block weitergegeben
wird.
3.3.3 DEFINITION UND ANWENDUNG VON
AUSNAHMEN
Zum gezielten Auslösen einer Ausnahme dient die throwAnweisung. Als Parameter wird dabei ein Throwable-Objekt benötigt. Eine Klasse, die eine Ausnahme auslösen
kann, hat folgenden Aufbau:
public DemoClass trows DemoException{
// etc...
if (Fehler_ist_aufgetreten)
trow new DemoException;
// etc...
}
Durch die Angabe „throw DemoException“ bei der Klassendefinition weiss der Compiler, dass aufrufende Methoden dieser Klasse Ausnahmen des Typs „DemoException“
abfangen können.
catch-Anweisung
wird in Hierarchie
gesucht
Tritt nun zur Laufzeit ein Fehler auf, so wird über alle aufrufenden Methoden (d.h. über den gesamten Call-Stack)
hinweg nach einer catch-Anweisung gesucht, die diesen
bearbeiten kann. Die erste, die in der Hierarchie gefunden
wird, wird benutzt. Auf diese Weise ist es möglich, das
Verhalten bei Ausnahmen den eigenen Bedürfnissen anzupassen.
Der Compiler prüft beim Übersetzen, ob für jede denkbare Ausnahme ein geeigneter catch-Block verfügbar ist.
Nur wenn keiner gefunden wurde, wird das JavaProgramm übersetzt. Dies bedeutet allerdings nicht, dass
in Java-Programmen für alle denkbaren Ausnahmezustände, die zur Laufzeit auftreten können, grundsätzlich
eine catch-Anweisung definiert werden muss. Für die sogenannte „Runtime-Exception“ übernimmt das System
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
38
die Bearbeitung, wenn nicht extra eine Fehlerbehandlung
für diesen Exception-Typ eingerichtet wurde. Tritt eine Runtime-Exception auf, die nicht vom Programm abgefangen wird, terminiert die Java Virtual Machine das Programm.
3.4 Threads
Moderne, verteilte Applikationen müssen häufig viele
Dinge parallel erledigen. Daher reicht ein einziger Steuerfluß, wie er für sequentielle Applikationen typisch ist, nicht
aus. In der Praxis wird dem Problem meist durch die Verwendung (quasi-)paralleler Prozesse begegnet. Bedingt
durch verschiedene Nachteile (relativ grosser Overhead,
erschwerte Kommunikation und Synchronisation) besteht
zunehmend der Bedarf, mehrere Steuerflüsse innerhalb
eines Programms, die als Threads bezeichnet werden, zu
realisieren. Derartige Programme tragen oft das Attribut
multithreaded.
Threads sind preemptiv
Java-Threads sind generell preemptiv, allerdings nur dann
time-sliced, wenn die verwendete Thread-Implementierung des Betriebssystems dies unterstützt. Daher sollte der
Programmierer für eine gewisse Fairneß sorgen, um das
Verhungern anderer Threads zu verhindern. Auf allen Systemen wird einem Thread die Steuerung entzogen, sobald ein anderer Thread mit höherer Priorität ausgeführt
werden kann.
Ein von Consumer und Producer gemeinsam genutztes
Objekt (der kritische Bereich) wird durch einen Monitor
geschützt. Dies geschieht automatisch durch die Verwendung des Schlüsselwortes synchronized. Dadurch ist
gesichert, daß die Methoden des Objekts (die kritischen
Abschnitte) atomare Operationen darstellen.
3.4.1 FUNKTIONSWEISE VON THREADS
Erzeugung eines
Threads mit run()
Beim Starten eines Java-Programms wird automatisch ein
Thread erzeugt. Um einen eigenen Thread zu erzeugen,
muss z.B. das Runnable-Interface implementiert werden.
Jede Klasse, die dieses Interface implementiert muss über
die Methode run() verfügen. Um einen Thread zu starten,
wird als erstes ein Objekt der Klasse instanziiert. Im nächsten Schritt muss ein Thread erzeugt werden. Der Konstruktor der Thread-Klasse übernimmt das runnable-Objekt und
nimmt alle notwendigen Initialisierungen vor. Zum Starten
wird schliesslich die start()-Methode des Threads aufgerufen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
39
3 Die Sprache Java
Neben run() gibt es noch die weiteren Methoden init(),
start() und stop(), die für den Start bzw. das Beenden des
Threads von Bedeutung sind.
Die folgende Abbildung zeigt die möglichen Zustände
eines Threads in Java:
Zustände eines Threads
Java bietet zudem die Möglichkeit, Threads in sogenannte Thread-Gruppen zusammenzufassen; aber generell
sollte diese Möglichkeit den Applikationen auf Systemebene vorbehalten bleiben.
Threads mit Prioritäten
Ausserdem können Threads mit Prioritäten versehen werden, sodass Threads mit höherer Priorität gegenüber
Threads mit niedriger Priorität Vorrang haben. Das ist nützlich, wenn bestimmte Threads immer ausgeführt werden
sollen, wenn sie nicht gerade auf irgend etwas warten.
Man sollte sich allerdings nicht auf strikte Prioritäten verlassen, sondern die Prioritäten vielmehr als Hinweise an das
System betrachten, die regeln, welche Threads vor anderen Zugriff auf den Prozessor bzw. die Prozessoren haben
sollen.
3.4.2 SYNCHRONISATIONS-ANWEISUNGEN
Wenn eine kritische Methode aufgerufen wird, welche
von keinem anderen Thread unterbrochen werden darf,
muss dieser Bereich geschützt werden; diesen kritischen
Methoden wird dazu in Java einfach das Schlüsselwort
synchronized vorangestellt. Ruft nun ein Thread eine solche Methode auf, wird diese für andere Threads gesperrt.
Erst wenn sie vollständig abgearbeitet wurde, gibt Java
sie wieder frei. Versucht dennoch bei einem ThreadWechsel ein anderer Thread eine gesperrte Methode aufzurufen, wird er so lange in einer Warteschlange plaziert,
bis diese wieder freigegeben wurde.
Monitore zur Sperrung und Freigabe
Die Aufgabe der Verwaltung der Sperrung bzw. Freigabe
der synchronized Methoden übernehmen sogenannte
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
40
Monitore:
Die Methoden wait() und ihre zwei Varianten mit einem
Timeout veranlassen den aktiven Thread, so lange zu warten, bis eine Bedingung erfüllt ist. Die Methode notify()
bzw. notifyAll(), die innerhalb einer synchronized Methode
aufgerufen werden muss, weckt den aktiven bzw. alle
Threads auf, um die Bedingung erneut zu prüfen, weil sich
etwas geändert hat.
3.5 Benennungskonventionen
In Java werden Klassen unter ihrem Realnamen abgelegt. Dadurch muß man beachten, daß ein File mit dem
Namen test.java nach der Compilierung unter Umständen mehrere Files erzeugt die zum Beispiel klasse1.class,
klasse2.class etc. heißen. Zum Auffinden der Klassen wird
vom ClassLoader der Klassen eine bestimmte Strategie
verfolgt. Klassen werden zu sogenannten Packages zusammengefaßt. Bestes Beispiel sind die Standard Librarys
deren Namen alle mit dem Präfix java. beginnen. Um den
Anspruch an die Dateisysteme nicht unnötig zu erhöhen
wird zum Beispiel für die Klasse java.awt.list der Filenamen
list.class Verzeichnis .\java\awt\ verwendet.
Inzwischen ist man dazu übergegangen die kompletten
Librarys in einem Archiv zu speichern (CLASSES.ZIP). Dieses
File darf bei der Installation von Java keinesfalls ausgepackt werden.
Zur Benennung von Klassen die (Inter-) Netz weit bekannt
sein sollen, gilt die Konvention als Präfix der Klassen den
eigenen URL zu verwenden (dadurch wäre es mit einem
geeigneten ClassLoader möglich Klassen automatisch in
der aktuellsten verfügbaren Version vom durch den URL
zu identifizierenden Server zu laden). Die Problematik der
unter Umständen recht langen Klassennamen wird derzeit
heftig diskutiert und ist auch reichlich umstritten.
3.6 Die Java-Packages
verwandte Klassen in Packages
In Java ist es möglich, verwandte Klassen in einem sogenannten Package zusammenzufassen. Bnötigt ein Programm die Klassen eines Packages, so importiert es einfach die notwendigen Dateien mit dem import-Befehl.
In Java gibt es sechs (sehr umfangreiche) Packages, die
standardmäßig zum Java Development Kit (JDK) gehören:
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
3 Die Sprache Java
41
java.lang:
Dieses Package beinhaltet wesentliche Java-Klassen. Dieses Package wird implizit in
jede Java-Datei importiert. So muß ein “import java.lang.*” nicht in einer Java-Datei
deklariert werden.
java.io:
Dieses Package enthält Klassen, die für die
Datenein- bzw. ausgabe benutzt werden
können.
java.util:
Enthält Utility-Klassen wie Hashtables, Vektoren, Zufallszahlen, Datum usw.
java.net:
Enthält Klassen für die Netzwerkverbindung.
Diese Klassen können zusammen mit den
Klassen aus dem java.io-Package benutzt
werden, um Daten aus dem Netzwerk zu lesen oder in das Netzwerk zu schreiben.
java.awt:
Mit diesem Package lassen sich plattformunabhängige GUI-Applikationen schreiben.
Es sei hier ausdrücklich darauf hingewiesen,
dass speziell dieses Package Java für die
Programmierung im Internet interessant
macht. Mit diesem Package erreicht man
einen Interaktivitätsgrad, der mit herkömmlicher CGI-Programmierung undenkbar
wäre.
java.applet:
Enthält Klassen für die Java-Applet-Programmierung. Diese Applets können dann
in jedem Java-kompatiblen Web-Browser
ablaufen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
42
4 Objekte und Klassen
4 Objekte und Klassen
Objekte als Programmabstraktion
Java ist eine objektorientierte Sprache; dies bedeutet,
dass in Java geschriebene Programme Objekte benutzen. Objekte sind eine Programmierkonstruktion, in welcher Daten einem Code zugeordnet werden, der mit diesen Daten arbeitet. Objekte werden durch ihre Klasse
charakterisiert, die man sich als eine Art Vorlage vorstellen
kann.
Die Konzepte von Java haben grosse Ähnlichkeit mit jenen von C++. Wer bereits Erfahrungen in C++ oder anderen objektorientierten Programmiersprachen hat, dem
wird vieles bekannt vorkommen, was Java zu bieten hat.
4.1 Einführung in Klassen und Objekte
Daten und Methoden definieren Inhalte
Eine Klasse ist eine Sammlung von Daten und Methoden,
welche diese Daten verarbeiten. Methoden sind eine Art
objektorientierte Bezeichnung für Prozeduren und Funktionen. Diese Daten und Methoden definieren Inhalte und
Fähigkeiten, welche als Objekte bezeichnet werden.
public class Circle {
public double x,y;
// Koordinaten des Zentrums
public double c;
// der Radius
// Methoden für die Berechnung von Umfang und Fläche
public double circumference() {return 2 * 3.14159 * r;}
public double area() {return 3.14159 * r * r;}
}
4.1.1 OBJEKTE ALS INSTANZEN VON KLASSEN
Mit einer Klasse allein lässt sich nichts anfangen, man benötigt ein Objekt als Instanz einer Klasse. Bei der Definition
einer Circle-Klasse wurde ein neuer Datentyp kreiert; nun
kann eine Variable dieses Typs deklariert werden:
Circle c;
Aber diese Variable c ist einfach die Bezeichnung einer
Referenz auf das Circle-Objekt und nicht das Objekt selber. In Java müssen die Objekte dynamisch erzeugt werden; dies geschieht z.B. mit dem Schlüsselwort new:
Circle c;
c = new Circle();
Nun ist eine Instanz auf die Circle-Klasse (ein Circle-Objekt) erzeugt und in einer Variablen vom Typ Circle zugeordnet worden.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
4 Objekte und Klassen
43
4.1.2 ZUGRIFF AUF OBJEKTDATEN
Zugriff mit PunktOperator
Nachdem ein Objekt erzeugt worden ist, kann man auf
dessen Datenfelder zugreifen. Die Syntax ist für C-Programmierer nichts unbekanntes:
Circle c = new Circle();
// Initialisierung auf Zentrum (2,2) und Radius 1
c.x = 2.0;
c.y = 2.0:
c.r = 1.0;
4.1.3 GEBRAUCH VON OBJEKTMETHODEN
Um auf die Methoden eines Objektes zuzugreifen, wird
dieselbe Syntax verwendet wie beim Zugriff auf die Daten
eines Objekts:
Circle c = new Circle();
double a;
c.r = 2.5;
a = c.area();
Der Methode wird also kein Argument übergeben. Das
Objekt, mit welchem man arbeitet, ist implizit Bestandteil
der Syntax. Dieselbe Feststellung kann man bei der Definition der Methode machen. Es ist Bestandteil der Sprache,
dass eine Methode mit den Instanzen einer Klasse operiert, in welcher sie definiert ist.
4.1.4 FUNKTIONSWEISE
Wie kann eine Methode ohne Argumente wissen, mit welchen Daten sie arbeiten soll? In Wirklichkeit hat die area()Methode ein Argument. area() ist implementiert mit einem impliziten Argument, welches in der Deklaration der
Methode nicht sichtbar ist. Dieses Argument heisst this und
referenziert „dieses“ Objekt Circle, durch welches die Methode aufgerufen wurde.
implizites this als
Argument
Das implizite this-Argument ist aus der Methodenbezeichnung nicht ersichtlich, weil es normalerweise gar nicht benötigt wird. Immer wenn eine Methode in Java auf Datenfelder einer Klasse zugreift, werden die Datenfelder
des eigenen Objektes referenziert.
Man kann das Schlüsselwort this explizit verwenden, um
klar zu machen, dass die eigenen Variablen bzw. Methoden verwendet werden.
Eine Instanz, bei welcher das Schlüsselwort this nötig ist, ist
wenn ein Methodenargument oder eine lokale Variable
in einer Methode dieselbe Bezeichnung hat wie eines der
Elemente der Klasse. In diesem Fall muss das Schlüssel-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
44
4 Objekte und Klassen
wort this verwendet werden, um auf das gewünschte Feld
zuzugreifen.
4.2 Erzeugen von Klassen
jede Klasse hat
mindestens einen
Konstruktor
Bei der Definition einer Klasse erscheint ein Paar Klammern, welches an einen Funktionsaufruf erinnert. Eigentlich geschieht auch nichts anderes; jede Klasse in Java
hat mindestens eine Konstruktor-Methode, welche denselben Namen trägt wie die Klasse. Der Zweck dieses Konstruktors besteht darin, die nötigen Initialisierungen vorzunehmen. Falls für eine bestimmte Klasse kein Konstruktor
definiert wird, so nimmt Java einen Default-Konstruktor,
welcher keine Argumente übernimmt und keine speziellen Initialisierungen unterstützt.
Das Schlüsselwort new erzeugt eine neue dynamische Instanz einer Klasse. Danach wird die Konstruktor-Methode
aufgerufen und vom neuen Objekt und den in Klammern
spezifizierten Argumenten durchlaufen.
4.2.1 DEFINITION EINES KONSTRUKTORS
Spezifizierung von
Initialisierungswerten
Das folgende Beispiel zeigt die Definition eines Konstruktors für das Circle-Objekt, welcher Initialisierungswerte für
das Zentrum und den Radius spezifiziert. Gleichzeitig wird
die Verwendung des this-Schlüsselwortes aufgezeigt:
public class Circle {
public double x,y,r;
// Zentrum und Radius
// Konstruktor
public Circle(double x, double y, double r)
{
this.x = x;
this.y = y;
this.r = r;
}
public double circumference() {return 2 * 3.14159 * r;}
public double area() {return 3.14159 * r * r;}
}
Mit diesem neuen Konstruktor wird die Initialisierung Teil
der Erzeugung eines Objektes.
Für dir Deklaration eines Konstruktors ist folgendes von Bedeutung:
- Der Konstruktor trägt immer denselben Namen wie die
dazugehörige Klasse.
- Der Rückgabewert ist implizit eine Instanz der Klasse.
- Es wird weder ein Rückgabewert spezifiziert noch das
Schlüsselwort void verwendet. Das this-Objekt wird impli-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
4 Objekte und Klassen
45
zit zurückgegeben; ein Konstruktor soll keine returnAnweisung enthalten, um einen Wert zurückzugeben.
4.2.2 MEHRFACHE KONSTRUKTOREN
verschiedene Arten der Initialisierung
Manchmal ist es wünschenswert, ein Objekt auf mehrere
verschiedene Arten zu initialisieren. Es kann z.B. sinnvoll
sein, den Radius eines Kreises ohne ein Zentrum oder einen Kreis mit demselben Zentrum wie ein bestehender
Kreis zu initialisieren. Es kann aber auch erwünscht sein,
alle Datenfelder mit Default-Werten zu initialisieren.
Eine Klasse kann eine beliebige Anzahl von KonstruktorMethoden aufweisen; allerdings müssen sich diese in bezug auf die Argumentenanzahl bzw. deren Datentypen
unterscheiden.
4.2.3 ÜBERLADEN VON METHODEN
Überraschend scheint, dass alle Konstruktor-Methoden
denselben Namen besitzen. Wie kann also der Compiler
diese voneinander unterscheiden?
Unterscheidung
anhand von Rückgabetyp und Argumente
In Java unterscheiden sich die Methoden durch ihren
Namen, ihren Rückgabetyp und durch Anzahl, Typ und
Position ihrer Argumente. Wenn eine Methode aufgerufen
wird, wobei mehrere mit demselben Namen bestehen, so
nimmt der Compiler automatisch jene Methode, dessen
Datentypen und Argumente passend sind.
Diese Art, mehrere Methoden mit demselben Namen und
unterschiedlichen Argumenten oder Rückgabetypen zu
definieren, nennt man Überladen von Methoden. Dies ist
allerdings nicht mit dem Überschreiben von Methoden zu
verwechseln (siehe Kapitel 4.7 Überschreiben von Methoden)
4.3 Klassenvariablen
globale Variablen
wären machmal
von Vorteil
Im vorigen Beispiel einer Circle Klasse sind die Variablen x,
y und r deklariert. Jede Instanz einer Klasse, also jeder
Kreis, hat seine eigene Kopie dieser drei Variablen.
Manchmal wäre es von Vorteil, nur eine Kopie einer Variablen zu haben, wie eine globale Variable in C.
Java erlaubt keine globalen Variablen, da jede Variable
innerhalb einer Klasse deklariert werden muss. Java verwendet das Schlüsselwort static, um anzuzeigen, dass ein
Feld oder eine Methode einer Klasse allen Instanzen dieser Klasse gemeinsam sein soll.
Diese Art von Variablen werden auch „statische Variablen“ genannt.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
46
4 Objekte und Klassen
4.3.1 BEISPIEL EINER KLASSENVARIABLEN
Das folgende Beispiel zeigt eine mögliche Verwendung
einer solchen Klassenvariablen. Es wird eine Klassenvariable deklariert, welche bei jeder neuen Instanzierung der
Klasse inkrementiert wird:
public class Circle {
static int num_circles = 0;
public double x,y,r;
// Klassenvariable
// Instanzen
public Circle(double x, double y, double r){
this.x = x; this.y = y; this.r = r;
num_circles++;
}
public Circle(double r) {this(0.0,0.0,r);}
public Circle(Circle c) {this(c.x,c.y,c.r);}
public Circle() {this(0.0,0.0,1.0);}
public double circumference() {return 2 * 3.14159 * r;}
public double area() {return 3.14159 * r * r;}
}
4.3.2 ZUGREIFEN AUF KLASSENVARIABLEN
Da die Klassenvariable eng mit der Klasse verbunden ist,
erfolgt auch der Zugriff meistens über die Klasse:
System.out.println(„Anzahl Kreise:“ + Circle.num_circles);
Will man von einer fremden Klasse auf diese Methode zugreifen, so ist es nötig, den Klassennamen der Methode
voranzustellen (Circle.num_circles).
4.3.3 GLOBALE VARIABLEN ?
Klassenvariable
entspricht einer
globalen Variablen
Wie bereits erwähnt kennt Java keine globalen Variablen.
Eigentlich ist aber die Klassenvariable Circle.num_circles
nichts anderes.
Der Unterschied zu einer globalen Variable in C besteht
darin, dass es zu keinen Namenskonflikten kommen kann.
Jede Klassenvariable ist Teil einer Klasse und innerhalb
dieser Klasse einmalig; wird nun der Klassenvariablen der
Name der Klasse vorangestellt, sind Konflikte nicht möglich.
4.3.4 KONSTANTEN
Eine spezielle Art von Klassenvariablen bilden die Konstanten. Mit dem Schlüsselwort final lässt sich eine Variable
definieren, deren Wert sich nicht verändern lässt.
public class Circle{
public static final double PI = 3.14159265;
public double x,y,r;
// etc.....
}
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
4 Objekte und Klassen
47
Der Compiler von Java setzt die so deklarierte Variable
(static und final) direkt um, ähnlich wie die PräprozessorAnweisungen in C (# define).
4.4 Klassenmethoden
Klassenmethoden
sind statische Methoden
Wie der Name bereits andeutet, sind die Klassenmethoden Methoden der Klassen und nicht der Instanzen. Klassenmethoden werden auch etwa als „statische Methoden“ (static methods) bezeichnet.
Sie unterscheiden sich von den Instanzenmethoden wie
z.B. area() im Circle-Beispiel wie folgt:
- Klassenmethoden werden mit dem Schlüsselwort static
deklariert.
- Klassenmethoden werden eher durch die Klasse aufgerufen als durch die Instanz.
- Klassenmethoden können auch als „globale“ Methoden angesehen werden. Da sie durch ihren Klassennamen referenziert werden müssen, besteht keine Gefahr
für Namenskonflikte.
4.4.1 BESONDERE MERKMALE
Klassenmethoden
ohne this
Klassenmethoden unterschieden sich in einem weiteren
wesentlichen Punkt von Instanzenmethoden: sie durchlaufen keine implizite this-Referenz.
Durch diese Tatsache werden sie zur geschlossensten Methode, die Java zu bieten hat und gleicht einer „normalen“ C-Prozedur.
Die Klassen System und Math z.B. bieten beide eine grosse
Sammlung von Klassenmethoden an.
4.4.2 BEISPIEL EINER KLASSENMETHODE
Das folgende Beispiel der Definition einer Circle-Klasse
zeigt sowohl eine Instanz wie auch eine Klassenmethode:
public class Circle{
public double x,y,r;
// Instanzenmethode
public Circle bigger(Circle c){
if (c.r > r) return c; else return this;
}
// Klassenmethode
public static Circle bigger(Circle a, Circle b){
if (a.r > b.r) return a, else return b;
}
// etc....
}
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
48
4 Objekte und Klassen
Der Aufruf der Instanzenmethode sieht folgendermassen
aus:
Circle a = new Circle(2.0);
Circle b = new Circle(3.0);
Circle c = a.bigger(b);
// oder b.bigger(a)
Der Aufruf der Klassenmethode hingegen lautet:
Circle a = new Circle(2.0);
Circle b = new Circle(3.0);
Circle c = Circle.bigger(a,b);
Keine dieser Methoden ist die einzig richtige; der Einsatz
hängt mehr vom eigenen Programmierstil ab als von syntaktischen Regeln.
4.4.3 STATISCHE INITIALISIERUNG
Sowohl Klassen- als auch Instanzenvariablen können in
ihrer Deklaration über Initialisierer verfügen.
Klassenvariablen werden initialisiert sobald sie erstmals
geladen werden; bei Instanzenvariabeln hingegen erfolgt
die Initialisierung bei der Erzeugung des Objektes.
statische Initialisierer als „Konstruktor“ für Klassenvariablen
Manchmal werden komplexe Initialisierungen benötigt.
Für Instanzenvariabeln gibt es die Konstruktor-Methode,
welche ausgeführt wird, sobald eine neue Instanz der
Klasse erzeugt wird. Java erlaubt es ausserdem, eine Initialisierungsmethode für Klassenvariablen zu schreiben.
Solche Methoden werden als statische Initialisierer bezeichnet.
Die Syntax von statischen Initialisierern ist auf den ersten
Blick eher ungewöhnlich. Ein statischer Initialisierer besitzt
weder Argumente noch einen Rückgabewert. Es ist nicht
einmal erforderlich, einen Namen zu vergeben.
4.5 Löschen von Objekten
Wie bereits festgestellt wurde (Kapitel 3.2.5 Müllabfuhr,
„Garbage Collector“), braucht sich der Programmierer in
Java keine Gedanken zu machen, wie er nicht mehr benötigten Speicherplatz frei macht; dies erledigt der Garbage Collector von Java automatisch.
4.5.1 GARBAGE COLLECTOR
Thread mit tiefer
Priorität räumt auf
Der Garbage Collector läuft als Thread von tiefer Priorität
dauernd im Hintergrund einer Java-Umgebung. Dies führt
dazu, dass er immer in Aktion tritt, wenn sonst auf dem
System „nicht viel los ist“.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
4 Objekte und Klassen
49
4.5.2 FINILIZATION-METHODE
Finilization-Methode als Destruktor
Ebenso wie es eine Konstruktor-Methode für die Initialisierung eines Objektes gibt, bietet Java eine Finilization-Methode an. In C++ nennt man dies auch etwa Destruktoren. Diese Methode wird für vielerlei „Aufräumarbeiten“
verwendet.
Solche Aufräumarbeiten sind z.B. die Freigabe von verschiedenen Ressourcen wie File-Deskriptoren oder Sokkets. Der Garbage-Collector ist nur in der Lage, den Speicher freizugeben; offene Files oder Netzwerkverbindungen müssen von der Finilization-Methode freigegeben
bzw. geschlossen werden.
4.6 Klassenhierarchie und Vererbung
Die revolutionäre Möglichkeit der objektorientierten Technik ist die Vererbung von Daten und Methoden einer Klasse an eine andere.
Vererbung mit
Steuerung der Berechtigungen
Bei der Verwendung wird eine Beziehung zwischen Oberund Unterklasse hergestellt. Der Vererbungsvorgang kann
über die Zugriffsberechtigung so gesteuert werden, dass
die abgeleiteten Klassen alle oder nur Teile der Eigenschaften der Basisklasse erben.
4.6.1 VERERBEN VON KLASSEN
Um aus der Circle-Klasse, welche die mathematischen
Methoden definiert, so zu erweitern, dass die Kreise gezeichnet werden können, muss eine GraphicCircle-Klasse
definiert werden. Diese GraphicCircle-Klasse ist eine Erweiterung bzw. Unterklasse der Circle-Klasse.
public class GraphicCircle extends Circle
Das Schlüsselwort extends sorgt dafür, dass GraphicCircle
eine Unterklasse der Circle-Klasse wird und die Variablen
und Methoden dieser Klasse erbt.
4.6.2 ENDKLASSEN
Wenn eine Klasse mit dem Schlüsselwort final deklariert
wird, kann sie nicht erweitert oder weitervererbt werden.
Die Klasse java.lang.System ist ein Beispiel einer solchen
Endklasse.
4.6.3 KLASSENHIERARCHIE
Jede Klasse verfügt über eine Oberklasse wie z.B. Circle
für GraphicCircle; die einzige Ausnahme bildet die Klasse
Object, welche an der Wurzel der Klassenhierarchie steht.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
50
4 Objekte und Klassen
Object
Circle
GraphicCircle
Math
System
Component
Container
Panel
Button
List
Klassenhierarchie
4.6.4 UNTERKLASSEN UND KONSTRUKTOREN
Auch für jede Unterklasse lässt sich natürlich eine Konstruktor-Methode definieren. Im folgenden Beispiel sehen wir
eine mögliche Konstruktor-Methode für die neue GraphicCircle-Klasse:
public GraphicCircle(double x, double y, double r,
Color outline, Color fill)
{
this.x = x;
this.y = y;
this.r = r;
this.outline = outline;
this.fill = fill;
}
Dieser Konstruktor erbt alle Variablen und Klassen der Circle-Klasse und initialisiert dessen Variablen. Dies kopiert in
Wirklichkeit den Code des Circle-Konstruktors.
Das nächste Beispiel zeigt, wie man den Circle-Konstruktor
innerhalb des GraphicCircle-Konstruktors aufrufen kann:
© J.-P. Thomsen 1996
28.10.96 15:53
Applet
Java - Tutorial
51
4 Objekte und Klassen
public GraphicCircle(double x, double y, double r,
Color outline, Color fill)
{
super(x,y,r);
this.outline = outline;
this.fill = fill;
}
mit super den
Konstruktor der
Obeklasse aufrufen
Das Schlüsselwort super ermöglicht es, den Konstruktor
der Oberklasse aufzurufen. Die Verwendung des super
Schlüsselwortes erfolgt analog dem Schlüsselwort this, um
eine Konstruktor-Methode einer Klasse von einer anderen
Klasse aus aufzurufen.
Die Benutzung beider Methoden ist gewissen Einschränkungen unterworfen:
- super kann auf diese Art nur innerhalb einer KonstruktorMethode verwendet werden.
- Der Aufruf des Konstruktors einer Oberklasse muss als erste Anweisung innerhalb einer Konstruktor-Methode erscheinen. Der Aufruf muss vor der Deklaration der Variablen erfolgen.
4.6.5 VERKETTUNG VON KONSTRUKTOREN
Wenn eine Klasse definiert wird, garantiert Java, dass der
Konstruktor dieser Klasse aufgerufen wird, sobald eine Instanz dieser Klasse bzw. einer Unterklasse erzeugt wird.
jeder Konstruktor
muss Konstruktor
der Oberklasse
aufrufen
Dafür muss Java sicherstellen, dass jeder Konstruktor den
Konstruktor seiner Oberklasse verwendet. Wenn die erste
Anweisung in einem Konstruktor nicht explizit mit dem super Schlüsselwort den Konstruktor seiner Oberklasse aufruft, fügt Java implizit einen super()-Aufruf ein, der den
Konstruktor der Oberklasse ohne Argumente aufruft. Verfügt diese Oberklasse über keinen Konstruktor ohne Argumente, so führt dies zu einem Compilerfehler.
In einem Fall wird von dieser Regel des Aufrufs des Konstruktors in der Oberklasse abgewichen: wenn in der ersten Zeile eines Konstruktors ein anderer Konstruktor derselben Klasse mit dem Schlüsselwort this aufgerufen wird.
Diese Art Konstruktoren aufzurufen, von Unterklasse zu
Oberklasse bis zur Wurzel der Klassenhierarchie der Klasse
Object, nennt man Verkettung von Konstruktoren.
4.6.6 DER DEFAULT-KONSTRUKTOR
Falls in Java eine Klasse ohne Konstruktor-Methode deklariert wird, fügt Java implizit einen Konstruktor hinzu. Dieser
Default-Konstruktor macht nichts anderes, als den Konstruktor seiner Oberklasse aufzurufen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
52
4 Objekte und Klassen
4.7 Überschreiben von Methoden
Methode mit
identischem
Namen, Rückgabetyp, Argumenten
Wenn eine Klasse eine Methode mit identischem Namen,
Rückgabetyp und Argumenten definiert wie eine Methode einer Oberklasse, so nennt man dies überschreiben
von Methoden. Wird die Methode für ein Objekt der Klasse aufgerufen, so wird die neue Definition der Methode
verwendet und nicht die „alte“ in der Oberklasse.
Das Überschreiben von Methoden ist nicht zu verwechseln
mit dem Überladen von Methoden (siehe Kapitel 4.2.3
Überladen von Methoden). Das Überladen von Methoden definiert mehrere Methoden (in derselben Klasse) mit
demselben Namen aber unterschiedlichen Argumentenliste oder Rückgabetyp.
4.7.1 FINALE METHODEN
finale Methoden
können nicht erweitert werden
Ist eine Methode als final deklariert, bedeutet dies, dass
sie weder weitervererbt noch überschrieben werden
kann. Als static oder private deklarierte Methoden werden implizit als finale Klassen betrachtet.
4.7.2 DYNAMISCHES NACHSCHLAGEN DER METHODE
Wenn in einem Array von Circle- und Ellipse-Objekten,
(wobei die Ellipse-Klasse eine Unterklasse der Circle-Klasse
ist und deren area()-Methode überschreibt) die Fläche
berechnet werden soll, woher weiss der Compiler, welche
area()-Methode er aufrufen soll?
Der Compiler weiss es nicht und kann es auch gar nicht
wissen. Es ist der Java-Interpreter, der zur Laufzeit feststellt,
welches Objekt im Array zur Klasse Circle und welches zur
Klasse Ellipse gehört. So ist es möglich, die richtige area()Methode für jedes Objekt aufzurufen. Dieselbe Technik
wird übrigens in C++ für „virtual functions“ verwendet.
4.7.3 AUFRUFEN EINER ÜBERSCHRIEBENEN METHODE
mit super lassen
sich überschriebene Methoden
aufrufen
Durch Überschreiben einer Methode wird die ursprüngliche Methode verborgen; trotzdem bleibt diese weiterhin
verfügbar. Um die Originalmethode innerhalb einer Klassendefinition aufzurufen, benutzt man das Schlüsselwort
super; damit gibt man den Methodenaufruf in der Hierarchie nach oben weiter.
4.7.4 VERKETTUNG VON FINALIZER-METHODEN
keine automatische Verkettung
von Finalizer-Methoden
Im Gegensatz zu den Konstruktoren werden die Finalizer
(Destruktoren) in Java nicht automatisch verkettet. Wenn
in einer Klasse eine finalize()-Methode definiert wird, kann
eine finalize()-Methode einer Oberklasse überschrieben
werden. Wenn nun die Unterklasse die finalize()-Methode
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
53
4 Objekte und Klassen
der Oberklasse nie aufruft, kann es vorkommen, dass dessen Ressourcen nicht wie gewünscht freigegeben werden.
Um dies zu verhindern, sollte sichergestellt werden, dass
die finalize()-Methode der Oberklasse aufgerufen wird.
Deshalb sollte als letzte Anweisung einer finalize()-Methode immer die finalize()-Methode der Oberklasse aufgerufen werde:
super.finalize();
4.8 Geheimhaltung und Datenkapselung
Klassen verbergen
Daten gegen aussen
Wie wir bereits festgestellt haben, ist eine Klasse eine
Sammlung von Daten und Methoden. Ein wichtiger Punkt
der objektorientierten Technik ist das Verbergen der Daten gegen aussen, sodass sie nur durch die Methoden
sichtbar werden. Diese Technik wird Datenkapselung genannt.
Ein wichtiger Grund dafür, besteht darin, dass die Daten
so vor unkontrolliertem Zugriff und Manipulationen geschützt werden können.
4.8.1 SICHTBARKEIT VON DATEN, METHODEN,
KLASSEN
Modifier regeln
Sichtbarkeit und
Zugriffe
Mit einem sogenannten Modifier lässt sich spezifizieren,
welche Klassen, Methoden und Variablen für andere
sichtbar sind:
public:
Die Klasse ist von überall sichtbar. Die
Methode und Variablen sind überall
sichtbar, wo auch die Klasse sichtbar
ist.
protected:
Die Methoden und Variablen sind
durch das ganze Package einer Klasse hindurch sichtbar. Eine Klasse kann
nicht protected sein. Eine Unterklasse
eines anderen Packages als die
Oberklasse kann auf die Felder zugreifen nicht aber auf die Felder der
Oberklasse.
default:
Wenn kein Modifier spezifiziert wird,
sind die Klassen, Interfaces, Methoden
und Variabeln nur innerhalb des
Packages überall sichtbar.
private protected: Die Methoden und Variablen sind nur
innerhalb der eigenen Klasse und in ih-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
54
4 Objekte und Klassen
ren Unterklassen sichtbar. Klassen können nicht private protected sein. Eine
Unterklasse kann auf die Felder durch
die Instanz zugreifen aber nicht auf
die Instanzen einer Oberklasse.
privat:
Methoden und Variablen sind nur innerhalb der eigenen Klasse sichtbar.
Klassen können nicht private sein.
4.8.2 DATENZUGRIFF DER METHODEN
Die folgende Tabelle zeigt, in welchen Fällen auf die Felder zugegriffen werden kann bzw. weitervererbt werden
können.
Situation
Zugriff auf fremde Klassen desselben Packages
Zugriff auf Unterklassen desselben Packages
Zugriff auf fremde Klassen
fremder Packages
Zugriff auf Unterklassen desselben Packages
Vererbte Unterklassen desselben Packages
Vererbte Unterklassen fremder
Packages
public
default
protected
private
ja
private
protected
nein
ja
ja
ja
ja
ja
nein
nein
ja
nein
nein
nein
nein
ja
nein
nein
nein
nein
ja
ja
ja
ja
nein
ja
nein
ja
ja
nein
nein
Sichtbarkeit von Objekten3
4.9 Abstrakte Klassen und Interfaces
abstrakte Klassen
dienen als Basisklassen
In Klassenhierarchien ist es möglich, dass die Erzeugung
von Instanzen einer Basisklasse ausgeschlossen werden
soll, da mit ihr nur ein Konzept festgelegt wird, dessen verschiedene Ausprägungen in der abgeleiteten Klassen
spezifiziert werden müssen.
Diesen Effekt erzielt man, indem die Basisklasse als abstrakt definiert wird. Eine abstrakte Klasse kann nur als Basisklasse einer anderen Klasse verwendet werden. Die abstrakte Klasse kann nicht zur Instanzierung von Objekten
herangezogen werden.
4.9.1 ABSTRAKTE METHODEN
abstrakte Methoden enthalten keinen Code
Java ermöglicht die Definition von Methoden ohne Implementierungscode, indem die Methode als abstract
3
[Nutshell], Seite 179
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
55
4 Objekte und Klassen
definiert wird. In C++ kennt man diese Methode als „pure
virtual function“.
Abstrakte Klassen weisen ein paar besondere Eigenschaften auf:
- Eine Klasse mit einer abstrakten Methode gilt automatisch selber als abstrakt.
- Eine abstrakte Klasse kann nicht instanziert werden.
- Eine Unterklasse einer abstrakten Klasse kann instanziert
werden, wenn sie jede abstrakte Methode seiner Oberklasse überschreibt und selber für deren Implementierung sorgt.
- Wenn die Unterklasse einer abstrakten Klasse nicht alle
geerbten abstrakten Methoden implementiert, ist die
Unterklasse selber abstrakt.
4.9.2 INTERFACES
Ein Interface sieht aus wie eine abstrakte Klasse, abgesehen davon, dass das Schlüsselwort interface anstelle der
Schlüsselworte abstract und class erscheint.
public interface Drawable {
public void setColor(Color c);
public void setPosition(double x, double y);
public void draw(DrawWindow dw);
}
in einem Interface
sind alle Methoden abstrakt
Während eine abstrakte Klasse einige abstrakte Methoden und auch nicht-abstrakte Methoden haben kann,
sind bei einem Interface alle Methoden implizit als abstrakt zu betrachten. Ausserdem müssen alle in einem Interface deklarierten Variablen static und final sein; dies
bedeutet sie müssen konstant sein.
4.9.3 MEHRFACHE INTERFACES
Ersatz für Mehrfachvererbung
Da Java die Mehrfachvererbung nicht erlaubt, bietet die
Möglichkeit von mehrfachen Interfaces eine willkommene Gelegenheit, einige Vorteile davon zu verwenden.
Die Implementation mehrerer Interfaces erfolgt einfach
durch komma-separierte Aufzählung der Interfaces in der
Deklaration der Klasse.
4.9.4 KONSTANTEN UND INTERFACES
Wie bereits erwähnt müssen sämtliche Variablen in einem
Interface Konstanten sein. Wenn nun eine Klasse dieses
Interface implementiert, so erbt es auch dessen Konstanten und kann diese direkt ansprechen ohne den Klassennamen zu nennen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
4 Objekte und Klassen
56
Falls durch mehrere Klassen innerhalb eines Packages
viele Konstanten benötigt werden, kann man diese Tatsache nutzen. Es lässt sich z.B. ein Interface mit allen Konstanten definieren und dieses Interface in den entsprechenden Klassen einführen. Damit liessen sich alle Konstanten ohne Nennung des Klassennamens direkt ansprechen.
4.9.5 VERERBUNG (ERWEITERUNG) VON INTERFACES
„Mehrfachvererbung“ bei Interfaces
Interfaces können Unter-Interfaces haben wie das Klassen
auch können. Ein Unter-Interface erbt alle abstrakten Methoden und Konstanten seines Ober-Interfaces und kann
neue abstrakte Methoden und Konstanten definieren. Ein
Interface unterscheidet sich in einem wichtigen Punkt von
den Klassen: ein Interface kann mehr als ein Interface
gleichzeitig erweitern.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
57
5 Programmierung
5 Programmierung
Dieses Kapitel soll anhand von Beispielen die Programmierung mit Java etwas genauer durchleuchten, um die
Theorie vielleicht etwas verständlicher zu machen.
5.1 Applets
Dieses Kapitel führt vom trivialen „Hello World“-Applet zu
komplexeren Applets und zeigt den Einsatz von Graphik,
den Umgang mit Benutzereingaben, das Lesen und Verarbeiten von Applet-Parametern, den Umgang mit Buttons, das Erzeugen von Threads sowie das Abspielen von
Audio-Clips.
5.1.1 EINFÜHRUNG IN APPLETS
Applet durchläuft
vier Zyklen
Ein Applet durchläuft vom Zeitpunkt, an dem es geladen
wird, bis zu dem, an welchem kein Zugriff mehr möglich ist
und vom System zurückgegeben wird, verschiedene Zyklen.
Start
Applet wird geladen
Initialisierung
Besuch der Seite
Verlassen einer Seite
Zerstörung
Ablegen der Seite
Stop
Der Applet-Zyklus
init():
wird einmal aufgerufen, wenn ein Applet in
das System geladen wird. Die beste Stelle,
um eventuell notwendige Initialisierungen
vorzunehmen.
start():
wird aufgerufen, um das Applet darüber zu
informieren, dass es nun loslaufen soll.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
5 Programmierung
58
Applets, die Threads für Animationen benutzen, würden jetzt also die Threads starten. Diese Methode wird nach init() und bei
jedem neuen Besuch des Applets in einer
Web-Seite aufgerufen.
stop():
wird aufgerufen, damit das Applet weiss,
dass es mit seiner Durchführung aufhören
soll. Bei Applets, die Threads benutzen, sollten die Thread mit dieser Methode gestoppt werden. Sie wird vor allem dann
aufgerufen, wenn die Web-Seite, die das
Applet enthält, durch eine andere Seite ersetzt wird.
destroy():
wird aufgerufen, damit das Applet weiss,
dass es vom System zurückgegeben wird
und alle Ressourcen freigeben bzw. zerstören soll, die es zugewiesen hat. Applets, die
Threads benutzen, zerstören die Threads in
dieser Methode. Vor destroy() wird stets
stop() aufgerufen.
5.1.2 DAS ERSTE APPLET
Das folgende Beispiel zeigt das wohl einfachste Applet in
Java. Dieses Beispiel benutzt die paint()-Methode und
erzeugt als graphische Ausgabe einen Text („Hello
World“).
import java.applet.*;4
import java.awt.*;
public class FirstApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hello World", 25, 50);
}
}
Das Applet kann nach der Kompilierung (javac FirstApplet.java) mit einem Web-Browser oder dem Applet Viewer
betrachtet werden.
5.1.3 ZEICHNEN VON GRAPHIKEN
Wenn man das vorherige Beispiel mit Objekten des Typs
Font und Color ergänzt, wird die Darstellung etwas auffälliger. Zudem wird die init()-Methode eingeführt, welche
eine einmalige Initialisierung vornimmt (beim erstmaligen
Erzeugen des Applets).
4
[Nutshell], Seite 87
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
59
5 Programmierung
import java.applet.*;
import java.awt.*;
public class SecondApplet extends Applet {
static final String message = "Hello World";
private Font font;
// einmalige Initialisierung
public void init() {
font = new Font("Helvetica", Font.BOLD, 48);
}
public void paint(Graphics g) {
// Die graphischen Elemente
g.setColor(Color.pink);
g.fillOval(10, 10, 330, 100);
g.setColor(Color.red);
g.drawOval(10,10, 330, 100);
g.drawOval(9, 9, 332, 102);
g.drawOval(8, 8, 334, 104);
g.drawOval(7, 7, 336, 106);
// Der Text
g.setColor(Color.black);
g.setFont(font);
g.drawString(message, 40, 75);
}
}
5.1.4 BEHANDLUNG VON EREIGNISSEN
Benutzer-Interaktionen erzeugen
Ereignisse
Die meisten Programme kommen kaum ohne BenutzerInteraktionen aus; d.h. es müssen Eingaben empfangen
und verarbeitet werden. Im folgenden Beispiel werden
die Methoden mouseDown() und mouseDrag() verwendet, um ein einfaches Zeichnen von Linien mit der Maus
zu ermöglichen.
import java.applet.*;5
import java.awt.*;
public class Scribble extends Applet {
private int last_x = 0;
private int last_y = 0;
// wird aufgerufen bei Mausklick
public boolean mouseDown(Event e, int x, int y)
{
last_x = x; last_y = y;
return true;
}
// wird aufgerufen bei fahren mit gedrückter Maustaste
public boolean mouseDrag(Event e, int x, int y)
{
Graphics g = getGraphics();
g.drawLine(last_x, last_y, x, y);
last_x = x;
5
[Nutshell], Seite 89
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
60
5 Programmierung
last_y = y;
return true;
}
}
5.1.5 DER EVENT-HANDLER
globale Methode
handleEvent()
verarbeitet alle Ereignisse
Die Standardmethoden zur Handhabung von Ereignissen
werden eigentlich von einer globalen Methode namens
handleEvent() aufgerufen. Dies handleEvent()-Methode
spiegelt die Art wider, in der das Abstract Window Toolkit
(AWT) im allgemeinen mit Ereignissen umgeht, die zwischen Anwendungskomponenten und Ereignissen aufgrund von Benutzereingaben stattfinden.
In der Standardmethode handleEvent() werden Ereignisse
verarbeitet und die entsprechenden Methoden aufgerufen. Um die Standardereignisse zu ändern oder eigene
Ereignisse zu definieren und weiterzugeben, müssen die
handleEvent überschrieben werden.
Um spezifische Ereignisse zu testen, muss die ID-Instanzvariable geprüft werden. Die Ereignis-ID ist eine Ganzzahl.
Die Event-Klasse definiert eine ganze Reihe von EreignisIDs als Klassenvariablen, die im Körper von handleEvent
getestet werden können. Da diese Klassenvariablen ganzzahlige Konstanten sind, eignet sich die switch-Anweisung
dafür besonders gut.
Wenn die handleEvent()-Methode überschrieben worden
ist, werden keine der Standardmethoden mehr automatisch aufgerufen. Sie müssen explizit im Körper von handleEvent aufgerufen werden. Es besteht natürlich auch die
Möglichkeit, mit super.handleEvent() die Methode der
Oberklasse aufzurufen, damit diese das Ereignis behandeln kann.
5.1.6 LESEN VON APPLET-PARAMETERN
Parameter machen Applets konfigurierbar
Um Applets konfigurierbar zu machen, werden die Applet-Parameter benötigt, welche auf der Web-Seite als
HTML-Fragment (gleich nach dem Aufruf des Applets)
spezifiziert werden.
<APPLET code="ColorScribble.class" width=300 height=300>
<PARAM name="foreground" value="0000FF">
<PARAM name="background" value="FFCCCC">
</APPLET>
Diese Parameter werden von der init()-Methode gelesen
und verarbeitet; ausserdem sollte in der init()-Methode
kontrolliert werden, ob solche Parameter definiert wurden
und gegebenenfalls eigene Default-Werte verwenden.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
61
5 Programmierung
5.1.7 EINFÜGEN VON SCHALTFLÄCHEN
Im folgenden Beispiel wird eine Schaltfläche zum Löschen
des gezeichneten Bildes eingefügt. In der init()-Methode
wird ein neuer Button erzeugt, dessen Vorder- und Hintergrundfarben definiert (unterschiedlich zum Hintergrund
der Zeichenfläche) und mit der add()-Methode dem
Applet beigefügt.
import java.applet.*;6
import java.awt.*;
public class ClearableScribble extends ColorScribble {
private Button clear_button;
public void init() {
// Initialisierung von ColorScribble
super.init();
// erzeugt einen Button.
clear_button = new Button("Clear");
clear_button.setForeground(Color.black);
clear_button.setBackground(Color.lightGray);
this.add(clear_button);
}
public boolean action(Event event, Object arg) {
// Click auf Button ?
// Falls nein: => Oberklasse
if (event.target == clear_button) {
Graphics g = this.getGraphics();
Rectangle r = this.bounds();
g.setColor(this.getBackground());
g.fillRect(r.x, r.y, r.width, r.height);
g.setColor(this.getForeground());
return true;
}
else return super.action(event, arg);
}
}
Bei einem Mausklick wird immer zuerst geprüft, ob dieser
dem entsprechenden Schaltknopf gilt; ist dies der Fall, so
wird die action()-Methode der Klasse aufgerufen. Andernfalls wird das Ereignis an die Oberklasse weitergegeben
und dort (falls vorhanden) die action()-Methode aufgerufen.
5.1.8 IMAGEMAP (BILDERKARTE)
Bildkarte mit
aktiven Bereichen
Als Imagemap bezeichnet man ein Bild mit spezifizierten
Regionen, die auf Mausklicks in diese Regionen reagieren
kann.
6
[Nutshell], Seite 94f
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
62
5 Programmierung
In der init()-Methode werden sowohl die Bilddatei wie
auch die gewünschten rechteckigen Regionen eingelesen bzw. spezifiziert. Die mouseDown()-Methode stellt fest,
wenn die Maustaste gedrückt wird. Falls dies innerhalb
eines definierten Rechteckes geschieht, wird dieses
Rechteck optisch hervorgehoben. Die mouseUp()-Methode erkennt anschliessend das Loslassen der Maustaste.
Geschieht dies innerhalb desselben Rechteckes, so wird
dies als korrekter Mausklick interpretiert und entsprechend
weiterverarbeitet.
5.1.9 ANIMATIONEN
rasche Abfolge
von Standbildern
Die Grundidee hinter der Animation besteht darin, Standbilder, die sehr ähnlich aussehen, sich aber doch geringfügig voneinander unterscheiden, in rascher Folge anzuzeigen, sodass eine Illusion von Bewegung entsteht. Die
Geschwindigkeit, mit der die Bilder präsentiert werden,
bezeichnet man als Frame-Rate (Bildwiederholgeschwindigkeit). Der Pseudo-Code für eine Animation sieht folgendermassen aus:
while (moreFramesToPaint) {
paintCurrentFrame();
sleep for some time;
// bestimmt die Frame-Rate
advanceToNextFrame();
}
Die start()-Methode erzeugt einen Thread für diese Animation und startet anschliessend diesen Thread.
5.1.10 SOUND
Java unterstützt das Abspielen von Sound eigenständig
oder in Verbindung mit laufenden Animationen. Die Unterstützung von Sound ist wie die von Bildern in den Applet- und awt-Klassen integriert, sodass die Verwendung
ebenso einfach ist wie das Laden und Anzeigen von Bildern.
In der derzeitigen Version unterstützt Java für Sound nur
das AU-Format von SUN.
Die einfachste Art, Sound abzurufen und abzuspielen bietet die play()-Methode der Applet-Klasse. Die play()-Methode ist vergleichbar mit getImage.
5.2 Graphical User Interface (GUI)
AWT definiert allgemeine Merkmale eines GUI
Das Abstract Window Toolkit (AWT) ist ein GUI-Toolkit, das
plattformübergreifend arbeitet. Es beinhaltet nicht alle
Merkmale einer bestimmten Plattform, sondern hat eine
allgemeine Reihe von Merkmalen, die von den meisten
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
63
5 Programmierung
Plattformen unterstützt werden. Das AWT ist erweiterungsfähig, kann also mit zusätzlichen Merkmalen ausgestattet
werden. Man kann also seine eigenen GUI-Controls in Java erstellen und sicher sein, dass sie auf allen Plattformen
laufen werden.
Folgende Abbildung zeigt die Hierarchie der wichtigsten
AWT-Klassen.
Die wichtigsten AWT-Klassen
5.2.1 DIE WICHTIGSTEN KLASSEN
Die wichtigsten Klassen des Abstract Window Toolkit (AWT)
sind:
Component: Abstrakte globale Klasse aller Elemente der
Benutzeroberfläche
Container:
Abstrakte Eigenschaften für ein Element,
das andere Elemente oder Container enthält. Basisklasse aller Komponenten.
Window:
Fenster auf der obersten Ebene der Benutzeroberfläche und Superklasse der Klassen
Frame und Dialog.
Frame:
Fenster mit Titel auf der obersten Ebene der
Benutzeroberfläche.
Dialog:
Dialogfeld für die Benutzeroberfläche.
FileDialog:
Dialogfeld für Dateioperationen der Benutzeroberfläche.
Panel:
Anzeigbarer Container.
Button:
Schaltfläche für die Benutzeroberfläche.
Canvas:
Zeichenbereich für die Benutzeroberfläche.
Checkbox:
Kontrollfeld
Label:
Beschriftung für Elemente der Benutzeroberfläche.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
64
5 Programmierung
List:
Listenfeld für die Benutzeroberfläche.
Scrollbar:
Bildlaufleisten-Objekt für die Benutzeroberfläche.
TextArea:
Mehrzeiliger editierbarer Textbereich, der
gescrollt werden kann.
Textfield:
Editierbares Textfeld mit fester Grösse.
5.2.2 DIE KLASSE EVENT
die Event-Klasse
beschreibt das
Ereignis
Sobald eine Komponente ein Ereignis verarbeiten muss,
wird es vom AWT an die Komponente geliefert. Die Klasse
Event besitzt Informationen, die das Ereignis beschreiben.
Falls die betreffende Komponente das Ereignis nicht bearbeitet, wird es an den Container weitergegeben, der
die Komponente enthält. Das ermöglicht es den Containern, alle Ereignisse zu bearbeiten, die die von ihnen abgeleiteten Klassen nicht bearbeiten wollen.
5.2.3 DIE KLASSE COMPONENT
Die Component-Klasse stellt die wohl wichtigste Klasse des
AWT dar und stellt einige wichtige Methoden zur Verfügung:
Dimension size()
Gibt Breite und Höhe der Komponente als Objekt der
Klasse Dimension zurück.
Rectangle bounds()
Gibt Koordinaten der Komponente zurück.
void enable()
Macht die Komponente für Benutzereingaben empfänglich.
void disable()
Macht die Komponente für Benutzereingaben unempfänglich.
void show()
Zeigt die Komponente.
void paint(Graphics g)
Wird vom AWT aufgerufen, wenn die Komponente neu
gezeichnet werden muss.
void repaint()
Aufforderung an AWT, die Komponente neu zu zeichnen.
void update(Graphics g)
Wird vom AWT aufgerufen, wenn es die repaint()-Methode aufgerufen hat.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
65
5 Programmierung
boolean mouseEnter (Event e, int x, int y)
Wird aufgerufen, wenn die Maus sich in den Bereich der
Komponente bewegt.
boolean mouseExit (Event e, int x, int y)
Wird aufgerufen, wenn die Maus den Bereich der Komponente verlässt.
boolean mouseMove (Event e, int x, int y)
Wird aufgerufen, wenn die Maus sich innerhalb der Komponente bewegt.
boolean mouseDrag (Event e, int x, int y)
Wird aufgerufen, wenn die Maus sich mit gedrückter
Maustaste bewegt.
boolean keyDown (Event e, int key)
Wird aufgerufen, wenn die Maustaste innerhalb der Komponente gedrückt wird.
boolean handleEvent (Event e)
Fängt alle Ereignisse der Komponente ab.
Dimension preferredSize()
Gibt die Dimension zurück, die diese Komponente gern
hätte.
Dimension minimumSize()
Gibt die Mindestgrösse zurück, die diese Komponente haben kann.
5.2.4 DIE KLASSE CONTAINER
Innerhalb der Component-Klasse ist es vor allem die Container-Klasse, welche sehr interessante Methoden zur Verfügung stellt:
void add(Component c):
Fügt dem Container eine Komponente hinzu
void add(String name, Component c):
Fügt die Komponente hinzu und verbindet den gegebenen Namen mit ihr. Manche Layout-Manager benutzen
diesen Namen, um Layout-Entscheidungen zu treffen.
void setLayout(LayoutManager I):
Layout-Manager
beschreibt Anordnung der Komponenten
Setzt den Layout-Manager für die betreffende Komponente. Er ist ein Objekt, das für die Anordnung der Komponenten im Container verantwortlich ist. Der Vorteil dieser Lösung gegenüber einer expliziten Positionierung der
Komponenten liegt darin, dass sie in einer, dass sie in einer
Multiplattform-Umgebung funktioniert und dass der Lay-
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
66
5 Programmierung
out-manager auch dann weiss, was zu tun ist, wenn die
Grösse des Containers geändert wird.
5.3 Eingabe und Ausgabe
Ein- und Ausgabe
als Datenströme
In diesem Kapitel geht es um Ein- und Ausgabeströme,
wie diese erstellt und benutzt werden sowie ihr Ende erkannt werden kann. Alle in diesem Kapitel diskutierten
Klassen und Methoden sind Bestandteil des java.ioPackages.
5.3.1 LESEN UND ANZEIGEN VON FILES
Um einen Eingabestrom von einer Datei zu lesen, stellt
Java die FileInputStream-Klasse zur Verfügung. Die allgemeinste Methode dieser Klasse zum Lesen von Eingabeströmen ist die read()-Methode.
Für die Anzeige des Files bietet Javas Abstract Window
Toolkit (AWT) mehrere Möglichkeiten; z.B. die TextAreaKlasse erlaubt es, Text auf dem Bildschirm anzuzeigen.
5.3.2 BESCHAFFUNG VON DATEI-INFORMATION
Mit Hilfe des FilenameFilter-Interfaces, welches vom FileDialog-Objekt und der File.list()-Methode benutzt wird,
lassen sich Files und Directories anzeigen. Die java.io.FileKlasse stellt zudem verschiedene Methoden wie canWrite(), canRead(), isFile(), isDirectory(), length(), lastModified() etc. zur Verfügung, um nähere Informationen über
die Files zu erhalten.
5.3.3 KOPIEREN EINES FILES
Kopieren bedeutet Lesen und
Schreiben von
Quell- zu Zieldatei
Die beiden Klassen FileInputStream und FileOutputStream
ermöglichen das Lesen von einer Quelldatei und das
Schreiben in eine Zieldatei. Vor dem eigentlichen Kopieren sollte aber mit Hilfe der File-Klasse kontrolliert werden,
ob die Zieldatei bereits existiert.
5.3.4 FILTERN VON EINGABEN
Mit Hilfe der FilterInputStream-Klasse sowie der DataInputStream-Klasse lässt sich auf einfache Art und Weise ein
Filter definieren. Damit lässt sich dank der readLine()-Methode ein Eingabestrom zeilenweise einlesen und diejenigen Zeilen rausfiltern, die z.B. einen entsprechenden Suchstring enthalten.
import java.io.*;7
// Diese Klasse ist ein Filter, der alle Linien herausfiltert, welche
7
[Nutshell], Seite 133f
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
67
5 Programmierung
// den spezifizierten Suchstring (substring) nicht enthalten..
public class GrepInputStream extends FilterInputStream {
String substring;
DataInputStream in;
public GrepInputStream(DataInputStream in, String substring) {
super(in);
this.in = in;
this.substring = substring;
}
// Dies ist der Filter: er liest vom DataInputStream,
// aber er gibt nur Zeilen zurück, welche den Suchstring enthalten.
public final String readLine() throws IOException {
String line;
do {
line = in.readLine();
}
while ((line != null) && line.indexOf(substring) == -1);
return line;
}
}
5.3.5 PIPES
Pipe entspricht
zwei separaten
Threads mit Datenströmen
Auch Pipes lassen sich durch zwei separate Threads, welche die Klasse PipedOutputStream bzw. PipedInputStream
benutzen, relativ einfach realisieren. Diese Pipes lassen
sich natürlich auch mit verschiedenen Filtern kombinieren
und ausbauen.
5.4 Networking
In diesem Kapitel soll besprochen werden wie URL-Klassen
benutzt werden, um URL-Verbindungen herzustellen. Im
weiteren soll gezeigt werden, wie Server mit Client via
Netz kommunizieren und Datenpakete senden bzw. empfangen können.
5.4.1 HERUNTERLADEN VON URL-INHALTEN
einfache Schnittstelle zum Netzwerk
Die URL-Klasse repräsentiert eine Internet Universe Resource Locator, d.h. eine Adressenstruktur, welche den
Standort eines Objektes im Netz genau definiert. Sie sorgt
für eine einfache Schnittstelle zum Netzwerk, um durch
ihre URL referenzierte Objekte herunterzuladen bzw. Datenströme zu öffnen und von diesen zu lesen oder in diese
zu schreiben.
Die einfachste Art, Daten einer URL von einer spezifizierten
WWW-Adresse herunterzuladen, bietet die getContent()Methode.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
68
5 Programmierung
5.4.2 BENUTZUNG EINER URL-VERBINDUNG
Dank der URLConnection-Klasse kann eine wesentlich
grössere Kontrolle über das Herunterladen von URL-Inhalten erreicht werden. Die Methoden dieser Klasse ermöglichen es zudem, Informationen über die Grösse, den Typ,
das Datum der letzten Änderung usw. von URL-Verbindungen zu erhalten. Ausserdem können mit Hilfe der DataInputStream-Klasse Textinhalte dieser Verbindung zeilenweise gelesen werden.
5.4.3 SENDEN UND EMPFANGEN VON DATENPAKETEN
Versand und Empfang von Datenpaketen ohne
Kontrollmechanismen
Das folgende Beispiel zeigt die Implementierung einer einfachen Netzwerk-Kommunikation mit Datenpaketen. Da
bei dieser Art der Kommunikation keine Kontrollmechanismen integriert sind, eignet sich sich nur für unkritische
Daten.
Um Daten senden und empfangen zu können, werden
die Klassen DatagramPacket und DatagramSocket benötigt.
Die Objekte werden auf unterschiedliche Art erzeugt und
initialisiert, je nachdem ob sie Daten empfangen oder
senden sollen:
5.4.3.1 Senden von Datenpaketen
Um ein Datenpaket zu senden, muss zuerst ein DatagramPacket-Objekt erzeugt werden, welches die zu sendenden Daten, die Länge der Daten sowie den Port des
Hosts, der die Daten empfangen soll, spezifiziert. Anschliessend kann die send()-Methode der DatagramSocketKlasse benutzt werden, um das Datenpaket zu senden.
import java.io.*;8
import java.net.*;
// Diese Klasse sendet den spezifizierten Text als Datenpaket zum Port
// 6010 des spezifizierten Hosts.
public class UDPSend {
static final int port = 6010;
public static void main(String args[]) throws Exception {
if (args.length != 2) {
System.out.println("Usage: java UDPSend <hostname> <message>");
System.exit(0);
}
// gibt die Internet-Addresse des spezifizierten Hosts
InetAddress address = InetAddress.getByName(args[0]);
8
[Nutshell], Seite 144
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
5 Programmierung
69
// konvertiert die Meldung zu einem Array von Bytes
int msglen = args[1].length();
byte[] message = new byte[msglen];
args[1].getBytes(0, msglen, message, 0);
// initialisiert das Datenpaket mit Daten und Adresse
DatagramPacket packet = new DatagramPacket(message,
msglen, address, port);
// erzeugt ein Socket und sendet das Datenpaket.
DatagramSocket socket = new DatagramSocket();
socket.send(packet);
}
}
5.4.3.2 Empfangen von Datenpaketen
Um Daten empfangen zu können, muss als erstes ein DatagramSocket-Objekt erzeugt werden, welches auf einem
einzelnen Port des lokalen Hosts hört. Dieses Objekt kann
nur jene Daten empfangen, die an diesen einzelnen Port
gesandt werden.
Als zweites muss ein DatagramPacket-Objekt erzeugt
werden, welches einen Buffer für den Empfang der Daten
definiert. Schliesslich braucht es noch die receive()-Methode, welche die Daten blockiert bis sie empfangen und
im Buffer gespeichert werden können. Die InternetAdresse und Port-Nummer des Senders werden ebenfalls
im Datenpaket gespeichert.
5.4.4 IMPLEMETIERUNG EINES SERVERS
zuverlässige Kommunikation via
Sockets
Die Socket-Klasse, welche eine „feste“ Verbindung für
Datenströme über das Netzwerk erlaubt, ist eine viel zuverlässigere Kommunikation als jene mit Datenpaketen.
Ein gemeinsames Modell der Kommunikation ermöglicht
es, von einem einzigen Server-Programm Daten an einen
oder mehrere Clients zu schicken.
Das Server-Programm benutzt die ServerSocket-Klasse,
um Verbindungen von Clients zu akzeptieren. Wenn ein
Client eine Verbindung zu einem Port herstellt, auf welchen das ServerSocket-Objekt hört, wird ein neues ServerSocket- alloziert für die Kommunikation mit dem Client.
Danach kann der Server weiter auf den Ports hören, um
zusätzliche Client-Verbindungen aufzubauen.
Dieses Server-Programm muss multithreaded sein, um effektiv arbeiten zu können. Während das Server-Objekt ein
eigener Thread ist, welcher in einer Schleife auf die Ports
für Verbindungen von Clients hört, wird für jede ClientVerbindung von der ServerSocket-Klasse ein neuer Thread
erzeugt. Das neue Objekt übernimmt die gesamte Kommunikation mit dem Client und seine Konstruktor-Methode
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
5 Programmierung
70
übernimmt die Initialisierung der Datenströme durch das
Socket-Objekt und startet den Thread.
5.4.5 IMPLEMETIERUNG EINES CLIENTS
Client kennt nur
einen Server
Der Client erzeugt ein Socket-Objekt, um die Verbindung
zum Server herzustellen. Danach wird ein DataInputStream-Objekt erzeugt, welches das zeilenweise Lesen
des Textes vom InputStream-Socket und Schreiben auf
den OutputStream-Socket ermöglicht. Schliesslich werden
Zeilen vom Standard-Input gelesen und zum Server geschrieben sowie die Antwort vom Server gelesen und auf
den Standard-Output geschrieben. Der Client existiert bis
er auf dem Eingabestrom des Sockets oder auf dem
Standard-Input ein „end-of-file“ erhält.
5.5 Kommunikation zwischen Applets
drei Arten der
Kommunikation
Ein Applet kann mit anderen Programmen auf drei Arten
kommunizieren:
- durch aufrufen von public-Methoden anderer Applets
auf der selben Seite.
- durch benutzen des java.applet-Packages, welches eine beschränkte Kommunikation mit dem Browser oder
Applet Viewer ermöglicht, der das Applet enthält.
- durch benutzen des java.net-Packages, um über das
Netzwerk mit anderen Programmen zu kommunizieren.
Das andere Programm muss aber auf dem selben Host
laufen, von welchem das Applet heruntergeladen wurde.
5.5.1 APPLETS AUF DER SELBEN SEITE
Mitteilungen von
Applet zu Applet
Applets können andere Applets finden und ihnen Mitteilungen senden. Dies unterliegt allerdings den folgenden
Einschränkungen:
- die Applets müssen auf der selben Web-Seite und im selben Browser-Fenster laufen.
- einige Applet Viewer erfordern, dass die Applets vom
selben Server stammen.
Ein Applet kann ein anderes Applet entweder durch seinen Namen (getApplet()-Methode) oder durch finden
aller Applets dieser Seite (getApplets()-Methode) aufspüren.
Um eine einfache Kommunikation zu ermöglichen, werden die zwei Objekte Sender und Empfänger benötigt,
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
71
5 Programmierung
damit Mitteilungen gesendet bzw. empfangen werden
können.
5.5.2 KOMMUNIKATION MIT DEM BROWSER
Informationen
vom Browser
Einige der java.applet.Applet- und java.applet. AppletContext-Methoden rufen verschiedene Arten der Kommunikation mit dem Browser oder Applet Viewer auf. Die
Methoden getDocumentBase() und getCodeBase() geben Informationen vom Browser (oder Applet Viewer)
über die Herkunft des Applets und seine HTML-Seite zurück.
Andere Methoden ermöglichen das Abrufen von Informationen über die Applet-Parameter, den Applet-Status
und anderes.
5.5.3 ARBEITEN MIT SERVER-APPLIKATIONEN
Kommunikation
mit Server
Java-Applets benutzen das java.net-Package zur Kommunikation über das Netzwerk. Die einzige Einschränkung
aus Sicherheitsgründen besteht darin, dass der einzige
Host, mit welchem ein Applet kommunizieren kann derjenige ist, von welchem das Applet heruntergeladen wurde.
Es lässt sich einfach herausfinden, von welchem Host ein
Applet herkommt:
String host = getCodeBase().getHost();
Für die Implementierung eines Servers siehe Kapitel 5.4.4
Implemetierung eines Servers.
5.5.4 UMGEHEN DER EINSCHRÄNKUNGEN
Server-Applikation
umgeht Einschränkungen
Wie in Kapitel „5.5.5 Möglichkeiten und Einschränkungen“
erläutert wird, sind die Applets aus Sicherheitsgründen
einigen Einschränkungen unterworfen.
Ein Weg, diese Einschränkungen zu umgehen, besteht
darin, eine Server-Applikation zu benutzen, welche auf
dem Host des Applets ausgeführt wird. Der Server kann
zwar nicht alle Einschränkungen umgehen, aber er schafft
einige zusätzliche Möglichkeiten: z.B. kann der Server zwar
keine Daten auf dem Host speichern, auf welchem das
Applet läuft, aber er kann auf dem Host, von welchem
das Applet herkommt, Dateien speichern.
Dies erlaubt es, dass zwei Applets, die sich auf verschiedenen Seiten befinden und auf verschiedenen Rechnern
ausgeführt werden, durch den Server miteinander kommunizieren können.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
72
5 Programmierung
5.5.5 MÖGLICHKEITEN UND EINSCHRÄNKUNGEN
Einschränkungen
Eines der Hauptziele bei der Entwicklung von Java war
eine grösstmögliche Sicherheit beim Ausführen von Applets zu gewährleisten. Um dies zu erreichen, waren einige
Einschränkungen erforderlich:
- ein Applet kann keine Bibliotheken mit nativen Methoden laden oder definieren
- ein Applet kann normalerweise auf dem Host, auf welchem es läuft, keine Dateien lesen oder schreiben
- ein Applet kann keine Netzwerkverbindungen herstellen
ausser zu dem Host, wo es herkommt
- ein Applet kann auf dem Host, auf welchem es läuft,
kein Programm starten
- ein Applet kann keine System-Eigenschaften lesen
Möglichkeiten
Andererseits bieten Applets aber auch Möglichkeiten, die
Java-Anwendungen nicht haben:
- Applets können Sound abspielen (siehe Kapitel 5.1.10
Sound)
- Applets, die in einem Web-Browser ablaufen, können
auf einfache Art HTML-Dokumente anzeigen (siehe Kapitel 5.5.2 Kommunikation mit dem Browser)
- Applets können auf public-Methoden anderer Applets
auf der selben Seite aufrufen (siehe Kapitel 5.5.1 Applets
auf der selben Seite)
Besonderheiten
Es gibt noch zwei weitere Besonderheiten für Applets,
welche bis jetzt unerwähnt blieben:
- ein vom lokalen Filesystem geladenes Applet hat nicht
die üblichen Einschränkungen wie ein über das Netzwerk geladenes Applet
- obwohl die meisten Applets ihre Ausführung beim Verlassen einer Seite stoppen, ist dies nicht unbedingt erforderlich
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
73
A Java Development Kit (JDK)
A Java Development Kit (JDK)
Das Java Development Kit (JDK) ist eine Sammlung von
Tools, die für die Erstellung von Java-Programmen benötigt werden. Das von SUN Microsystems entwickelte JDK ist
zur Zeit für folgende Plattformen verfügbar: SPARC Solaris,
x86 Sorais, Windows 95, Windows NT, MacOS.
Im folgenden sollen die Tools in knapper Form beschrieben werden. Für ausführliche Informationen mit Syntax
und Beschreibung der Optionen empfehle ich die WebSeite von SUN (http://java.sun.com/products/JDK/).
A.1 Der Applet Viewer (appletviewer)
Der Applet Viewer ermöglicht es, Applets ausserhalb eines Web-Browsers laufen zu lassen. Mit dem Applet
Viewer lassen sich auch Verbindungen via URL zu Dokumenten und Ressourcen herstellen, damit deren Applets
angezeigt werden.
A.2 Der Interpreter (java)
Damit lassen sich Bytecodes ausführen, die vom JavaCompiler (javac) erzeugt worden sind.
Der Interpreter erwartet, dass sich die Bytecodes für die
Klasse in einer Datei mit dem Namen Klassenname.class
befinden, die durch die Kompilierung der entsprechenden Quelldatei mit javac erzeugt worden ist.
A.3 Der Compiler (javac)
Der javac-Befehl kompiliert Java-Quelldateien zu JavaBytecodes. Die Bytecodes werden dann mit dem JavaInterpreter (java) interpretiert.
Der Name von Dateien, die Java-Quellcode enthalten,
muss mit der Extension .java enden. Der Compiler speichert für jede in den an javac weitergegebenen Quelldateien definierte Klasse die resultierenden Bytecodes in einer Datei mit dem Name Klassenname.class.
A.4 Der Dokument-Generator (javadoc)
Mit diesem Tool lassen sich automatische Dokumentationen im HTML-Format erstellen. Die Informationen werden
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
74
A Java Development Kit (JDK)
direkt aus dem Java-Quellcode geholt, vom speziellen
Kommentar (/** etc. */).
Javadoc kann als Argument der Name eines Packages
oder einer oder mehreren Dateien mitgegeben werden.
A.5 Native Method C File Generator (javah)
Dieses Tool generiert aus einer java-Klasse Header- und
Sourcefiles von C (*.h und *.c). Diese C-Files sorgen für die
notwendigen Informationen für die Implementierung von
sogenannten nativen Methoden der spezifizierten Klassen
in C.
Diese Header-Files deklarieren eine C-struct, welche Felder enthält, die mit den Instanz-Feldern der Java-Klassen
korrespondieren. Das Header-File deklariert auch eine
Prozedur, welche für jede der nativen Methoden, die Java-Klassen enthalten, implementiert werden muss.
A.6 Class Disassembler (javap)
Mit dem javap-Tool lassen sich Klassen-Dateien (*.class)
wieder in lesbarer Form darstellen. Es werden alle Deklarationen von nicht-private und nicht-protected Objekten,
Methoden, Konstruktoren und statischen Initialisierern in
jeder der spezifizierten Klassen ausgegeben, die als Argument mitgegeben werden.
A.7 Debugger (jdb)
Der Java-Debugger ist Text-basiert, Kommandozeilen-orientiert und besitzt eine ähnliche Syntax wie die UNIX-Debugger (dbx und gdb).
Wenn jdb mit dem Namen einer Java-Klasse aufgerufen
wird, startet er eine Kopie vom Java-Interpreter (java). der
jdb ist eigentlich selber ein Java-Programm, welches in
seiner eigenen Kopie des Java-Interpreters läuft. Dieser
neue Interpreter lädt die spezifizierte Klassendatei und
stoppt für das Debugging bevor der erste Java-Bytecode
ausgeführt wird.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
B Entwicklungs-Tools
75
B Entwicklungs-Tools
neue Entwicklungswerkzeuge
mit visueller Oberfläche
Das von SUN Microsystems entwickelte JDK erlaubt mit
seinen Kommandozeilen-Befehlen kein angenehmes und
zeitgemässes Arbeiten. Dies haben einige Softwarehersteller natürlich erkannt und haben damit begonnen, neue
Entwicklungsumgebungen für Java zu schaffen bzw. bereits bestehende C++-Entwicklungsumgebungen auf Java
anzupassen. Dies führt einerseits zu einer wahren Flut von
neuen Tools und zu Neuankündigungen bzw. -Erscheinungen im Wochentakt.
Im folgenden sollen einige davon kurz vorgestellt werden.
Diese Zusammenstellung erhebt natürlich keinerlei Anspruch auf Vollständigkeit, da dies auch gar nicht möglich ist. Eine aktuellere Übersicht lässt sich auf der WebSeite von Netscape einsehen (http://www.netscape.com/
comprod/products/navigator/version_2.0/java_applets/
java_development_tools.html).
B.1 Silicon Graphics: Cosmo Code
„Cosmo Code“ stellt ein ganzes Set von visuellen Tools für
Java zur Verfügung um plattformunabhängige interaktive
Applets, Anwendungen und Klassen zu entwickeln.
Nähere Infos: http://www.sgi.com/
B.2 BulletProof: JAGG
Jagg ist das erste Java-ODBC-Werkzeug auf dem Markt.
Mit Jagg lassen sich einfach SQL-Befehle von einem
Applet für einen Windows NT-Web-Server generieren, auf
welchem eine ODBC-Datenbank läuft.
Nähere Infos: http://www.bulletproof.com/
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
B Entwicklungs-Tools
76
B.3 Kinetix: Hyperwire
Hyperwire bietet einen schnellen und einfachen Weg, um
interaktive 2-D und 3-D Applets in Java zu erstellen. Hyperwire erfordert keine Programmierung und bietet eine
visuelle Umgebung zur Erzeugung von Applets.
Nähere Infos: http://www.ktx.com/
B.4 Aimtech: Jamba
Jamba ist ein visuelles Entwicklungswerkzeug, das es dem
Entwickler erlaubt, Java-Applets und Anwendungen ohne
grosse Programmierung zu entwickeln.
Nähere Infos: http://www.aimtech.com/
B.5 Rogue Wave Software: JFactory
Rogue Wave Software bietet eine komplette, visuelle Java-Entwicklungsumgebung für Win32 und Solaris an.
“JFactory” besteht aus einem Applikationsdesigner, einem Codegenerator und dem Compiler.
Nähere Infos: http://www.roguewave.com
B.6 Thought Inc.: Nutmeg
Nutmeg implementiert eine Smalltalk-ähnliche Klassenbibliothek für Java-Programme.
Nähere Infos: http://www.thoughtinc.com/
B.7 Spider Technologies: NetDynamics
NetDynamics ist eine Datenbank-Applikation mit visueller
Entwicklungsumgebung, einem Applikations-Server und
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
77
B Entwicklungs-Tools
einem skalierbaren Datenbank-Zugriff in einer robusten
Architektur für rasche Zugriffszeiten.
Nähere Infos: http://www.netdynamics.com/
B.8 Symantec: Symantec Café
Symantec Café ist die erste visuelle Entwicklungsumgebung für Applets und Anwendungen in Java. Symantec
Café integriert das JDK von SUN in seine Entwicklungsumgebung.
Nähere Infos: http://www.symantec.com
B.9 PowerProduction Software: WebBurst
WebBurst ist ein interaktives Java-Applet für Designer von
Web-Seiten ohne Programmiermöglichkeit.
Nähere Infos: http://www.powerproduction.com/
B.10 Microsoft: Visual J++
Microsoft hat seine bekannte Entwicklungsumgebung Visual C++ auf Java angepasst.
Nähere Infos: http://microsoft.com/visualj/
B.11 SUN Microsystems: Java Workshop
Sun Microsystems stellte auf der Cebit `96 eine erste Version ihrer Java-Entwicklungsumgebung “Java Workshop”
vor, die selbst in Java geschrieben wurde.
Nähere Infos: http://www.sun.com/sunsoft/Developerproducts/java/index.html
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
78
B Entwicklungs-Tools
B.12 Innovative Software: OEW
Innovative Software bietet ihr auf Java getrimmtes OEW
als ein Reverse/Forward-Engineering- und Designwerkzeug an.
Nähere Infos: http://www.isg.de/OEW/JAVA/
B.13 FishNet: Kawa:
Kawa stellt eine einfache visuelle Entwicklungsumgebung
für Java-Programme zur Verfügung.
Nähere Infos: http://www.fni.net/kawa/
B.14 PowerSoft: Optima++
PowerSoft will mit Optima++ auf den Markt. Optima++
setzt zwar weiterhin als primäre Programmiersprache C++
ein, soll aber lernen, Java-Applets zu erzeugen.
B.15 Natural Intelligence: Roaster
Natural Intelligence bietet für den Mac die integrierte Java-Entwicklungsumgebung Roaster an.
B.16 melonSoft Berlin: ACupOfCoffee
melonSoft Berlin bietet mit ACupOfCoffee den ersten
kompletten GUI-Builder für das Java-Abstract-WindowToolkit (AWT) an. ACupOfCoffee ist eine Palette für den
NextStep InterfaceBuilder.
B.17 Borland: Latte
Borland will in naher Zukunft ebenfalls eine integrierte Java-Entwicklungsumgebung anbieten. Diese soll ebenfalls
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
B Entwicklungs-Tools
79
plattformübergreifend sein (durch Entwicklung mit Java)
und hofiert unter dem Codename “Latte”.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
80
C Unterschiede C++ / Java
C Unterschiede C++ / Java
Feature
Zeiger
Unicode
Basis-Datentypen
Boolsche Werte
Felder (arrays)
Zeichenketten
Java
C++
-
char a ='ü';
a wird als 16bit Unicode
gespeichert
char, short, int, long, float,
double nur vorzeichenbehaftete Datentypen
boolean ist ein BasisDatentyp
Felder sind Objekte. Zur
Laufzeit wird eine Überprüfung auf korrekten Zugriff innerhalb der Dimension des Feldes durchgeführt (Bounds-checking).
Zeichenketten bestehen
aus 16bit Unicode-Charaktern String-Objekte für
konstante Zeichenketten
Stringbuf-Objekte zum Kopieren von Zeichenketten
-
int *a,b; a = &b;
'ö' ist 8bit
Unterstützung auch von
nicht vorzeichenbehafteten Datentypen
Felder werden statisch
alloziert und verhindern
keine Zugriff außerhalb
der definierten Grenzen
des Feldes.
int a[5]; a[10] = 10;
Feld von 8bit-Charactern:
char zeichenkette [10];
Aufzählungstyp
enum { ... };
typedef
typedef ... ;
Zusammengesetzte
struct a { ...
Datentypen und Varianunion b { ...
ten
Preprozessor
#define, #ifdef werden
ja
nicht unterstützt
#include
'import ;' stellt Schnittstelja
len aus anderen Objektmodulen zur Verfügung
NULL
null ist Schlüsselwort
#define NULL '0' NULL wird
durch Prepozessor im
Code ersetzt
// und /*...*/
Kommentare
//... und /*...*/
/**... */ wird zur automatischen
Dokumentation
von Schnittstellen verwendet
Vererbung aus mehreren class a extends b imple- class a : public b, public
Klassen (multiple inheri- ments c {...}
c {...}
tance)
Templates
template
Überladen von Operaclass complex {
toren
friend complex
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
C Unterschiede C++ / Java
Linker
>>>
Thread-Support
Heap-Verwaltung
Scoping
Parameterübergabe
main()
81
operator+(const
complex&, const complex&)
...
nicht benötigt, da interessentiell vorhanden
pretiert
nicht vorzeichenbehaftenicht vorhanden
ter bitweiser Shift nach
rechts
synchronized { ... } klammert kritischen Abschnitt
Garbage
Collection Freigabe von Speicherdurch Thread im Hinter- blöcken durch Programgrund
mieren (delete)
bclass::instance
an main (String args[]) - main(int argc,char argv
Arrays haben als Instanz- [])
variable length auch die
Anzahl der Elemente gespeichert
Unterschiede C++ / Java
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
D Weitere Informationen
82
D Weitere Informationen
D.1 Bücher
Addison-Wesley ist Herausgeber der offiziellen, von Sun
Microsystems autorisierten Originaldokumentationen zu
Java.
Die Autoren der Java-Series sind Mitglieder des JavaTeams bei Sun Microssystems, die diese Sprache entwikkelt haben. Unter ihnen sind berühmte Wissenschaftler
und Experten wie James Gosling, Bill Joy und Guy Steele.
Java-Serie von
SUN in englisch
James Gosling, Bill Joy, and Guy Steele, „The Java(tm)
Language Specification“, Addison-Wesley, 1996, 720 Seiten
Tim Lindholm and Frank Yellin, „The Java Virtual Machine
Specification“, Addison-Wesley, 1996, 448 Seiten
James Gosling, Frank Yellin, and The Java Team, „The Java Application Programming Interface - Volume 1: Core
Packages“, Addison-Wesley, 1996, 544 Seiten
James Gosling, Frank Yellin, and The Java Team, „The Java Application Programming Interface - Volume 2: Window Toolkit and Applets“, Addison-Wesley, 1996, 448 Seiten
Ken Arnold and James Gosling, „Java Programming Language“, Addison-Wesley, 1996, 352 Seiten
Java-Serie von
SUN in deutsch
Ken Arnold, James Gosling, „Die Programmiersprache Java“, Addison-Wesley, 1996, ca. 500 Seiten
James Gosling, Bill Joy, Guy Steele, „Java - Die Sprachspezifikation“, Addison-Wesley, 1996, ca. 300 Seiten
James Gosling und das Java-Team, „Java - Die Anwendungsprogrammierschnittstelle“, Addison-Wesley, 1996,
ca. 700 Seiten
Tim Lindholm, Frank Yellin, Bill Joy, Kathy Walrath, „Java Die Spezifikation der Virtuellen Maschine“, AddisonWesley, 1996, ca. 300 Seiten
Mary Campione, Kathy Walrath, „Das Java-Tutorial: Objektorientierte Programmierung für das Internet“, AddisonWesley, 1996, ca. 800 Seiten
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
D Weitere Informationen
83
ein Muss für JavaProgrammierer
David Flanagan, „Java in a Nutshell, A Desktop Quick
Reference for Java Programmers“, O'Reilly, 1996, 438 Seiten
weitere lesenswerte Bücher
Ralf Kühnel, „Die Java-Fibel, Programmierung interaktiver
Homepages für das World Wide Web“, Addison-Wesley,
1996. 224 Seiten
Laura Lemay, Charles Perkins, „Teach Yourself JAVA in 21
days“, sams.net, 1996, 527 Seiten
Arthur van Hoff, Sami Shaio, Orca Starbuck, „Hooked on
JAVA, Creating Hot Web Sites with Java Applets“, Addison-Wesley, 1996, 181 Seiten
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
84
D Weitere Informationen
John December, „JAVA, Einführung und Überblick. Verlag“, Markt & Technik, 1996, 290 Seiten
aktuelle Buchliste
Für eine aktuelle und ziemlich komplette Liste empfehle
ich folgende Homepage:
Java(tm) Books:
http://lightyear.ncsa.uiuc.edu/~srp/java/javabooks.html
D.2 Internet
Java Reference
http://java.sun.com/products/
Gamelan: Earthweb's Java Directory
http://www.gamelan.com
Java(tm) Books
http://lightyear.ncsa.uiuc.edu/~srp/java/javabooks.html
Einführung in Java
http://acc.de/java/
Die Javaseite bei Addison-Wesley
http://www.addison-wesley.de/News/Java.html
Java Resources
http://www.heise.de/ix/raven/Web/Java/
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
85
D Weitere Informationen
Cup O' Joe Java Shop
http://www.cupojoe.com/
JARS
http://www.jars.com/JARS
TeamJava JAVA Links
http://www.teamjava.com
Java Language Reference Information
http://www.javasoft.com/hooked/language-ref.html
The Java Oasis
http://www.oasis.leo.org/java/
We're New! - JavaMan
http://www.JavaMan.com/
Yahoo - Computers and Internet:Languages:Java
http://www.yahoo.com/Computers_and_Internet/Langua
ges/Java/
The Java(tm) Developers Kit 1.0.2
http://java.sun.com/java.sun.com/products/JDK/1.0.2/in
dex.html
JavaWorld - IDG's magazine for the Java community
http://www.javaworld.com/
Javology
http://www.magnastar.com/javology/
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
E Glossar
86
E Glossar
Bandbreite: Bezeichnet die Kapazität einer Netzverbindung. Je
höher die Bandbreite, desto mehr Bits lassen sich pro Sekunde übertragen.
Bit: Kleinste digitale Einheit, die entweder aus der Ziffer 0 oder 1
besteht. Ein Bit hat kaum Aussagewert. Deshalb werden
Bits in Gruppen dargestellt. 8 Bits stellen ein Byte dar. Alle
Arten von Daten wie Texte, Bilder, Videos und Töne können in Bits und Bytes dargestellt werden.
Browser: Software, um auf dem Web zu surfen. Marktführer in
dieser Sparte ist Netscapes Navigator, weitere Anbieter
sind unter anderen Microsoft mit dem Explorer und NCSA
mit Mosaic.
Firewall: Als 'Feuerwand' werden Sicherheitssysteme (ein Rechner)
bezeichnet, welche ein lokales Netz z. B. einer Firma vor
nicht autorisierten Benutzern aus dem Internet abschirmen.
FTP: Abkürzung für File Transfer Protocol. Bezeichnet einen InternetDienst, der vor allem für das Herunterladen von Software
und anderen Dateien von Hosts und Servern geeignet ist.
Homepage: Die Eintrittsseite einer Organisation, einer Firma oder
eines privaten Informationsanbieters auf dem Web.
Host: Zu deutsch heisst Host 'Gastgeber' und bezeichnet Grossrechner im Netz, welche man ansteuern kann.
HTML: (Hyper Text Markup Language). Eine Seitenbeschreibungssprache für das World Wide Web, welche u. a. HypertextVerknüpfungen und auch die Darstellung von multimedialen Daten erlaubt. HTML-Dokumente können von allen
Rechnern mit gängigen Betriebssystemen gelesen werden.
Hypertext: Eine logische Verknüpfung im World Wide Web,
welche auf eine andere Seite verweist. Hypertext-Links
sind farblich markiert und unterstrichen und führen per
Mausklick automatisch zu einem verknüpften Dokument,
das auf einem beliebigen Internet-Rechner rund um den
Globus abgelegt sein kann.
Intranet: Firmeninternes Netzwerk, das mit Software und Protokollen des Internets arbeitet, aber nur autorisierten Benutzern offensteht. Firewalls schützen das Intranet vor Eindringlingen.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
E Glossar
87
Provider: Zu deutsch auch Internet-Anbieter genannt. Provider
sind jene Firmen, welche Kunden gegen eine monatliche
Gebühr den Zugang zum Internet verschaffen. Provider
managen die technische Ausrüstung (Server, Mietleitung,
Modems) und leisten Support.
Server: Ein Rechner im Datennetz mit besonderen Aufgaben (zu
deutsch etwa 'Diener'), der von einzelnen PCs (Clients)
beansprucht werden kann. Server verwalten Netze, bieten Programme an oder managen spezielle Dienste wie
FTP oder elektronische Post.
TCP/IP: (Transfer Control Protocol/Internet Protocol). Das Kommunikationsprotokoll, auf dem das Internet basiert. Erlaubt
verschiedensten Rechnertypen wie Unix, Windows, Macintosh und OS/2 miteinander zu kommunizieren.
URL: (Universe Resource Locator). Adressenstruktur, welche den
Standort eines Objektes im Netz genau definiert. Der Aufbau der Adresse gibt auch einen Hinweis über die Art des
Dienstes. So beginnt zum Beispiel eine Adresse im WWW
typischerweise mit dem Auftakt 'http://www', ein FTPServer erkennt man am Adressenauftakt ftp...
World Wide Web: (oder kurz Web oder 3W). Internet-Informationsdienst mit einer grafischen Oberfläche, der HypertextDokumente, Bilder, 3D-Dokumente, animierte Sequenzen
oder auch Sounddaten enthalten kann. Das Web ist neben E-Mail der meistgenutzte Internet-Dienst.
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
F Abbildungen, Tabellen
88
F Abbildungen, Tabellen
F.1 Abbildungen
Das heterogene Internet..................................................... 17
Der Verifizierungsprozess ..................................................... 19
Zustände eines Threads ....................................................... 41
Klassenhierarchie ................................................................. 53
Der Applet-Zyklus ................................................................. 62
Die wichtigsten AWT-Klassen............................................... 68
F.2 Tabellen
Operatoren .......................................................................... 32
Schlüsselworte...................................................................... 36
Sichtbarkeit von Objekten................................................... 59
Unterschiede C++ / Java .................................................... 89
© J.-P. Thomsen 1996
28.10.96 15:53
Java - Tutorial
89
G Stichwortverzeichnis
G Stichwortverzeichnis
A
abstract 34; 54; 55
Abstract Window Toolkit 60; 62; 63; 66
abstrakte Klasse 12; 54; 55
abstrakte Methode 55; 56
ACupOfCoffee 78
add(Component c): 65
add(String name, Component c) 65
Animation 62
Anweisung 32; 33; 34; 36; 37; 44; 51; 53;
60
Anwendungen 7; 10; 20; 72; 75; 76; 77
Applet 19; 20; 57; 58; 59; 60; 61; 62; 70;
71; 72; 73; 75; 77
Applet Host 19
Applet Viewer 20; 58; 70; 73
Array 13; 26; 27; 29; 30; 31; 52; 68
Aufzählungstypen 22
Ausdrücke 12; 29; 32
Ausgabe 58; 65
Ausnahmen 25; 35; 36; 37
AWT 60; 62; 63; 64; 66
B
Bibliothek 15
boolean 25; 31; 34; 59; 61; 64; 65; 79
bounds() 61; 64
break 23; 32; 33; 34; 36
Button 27; 29; 61; 63
byte 25; 29; 32; 34; 68
Bytecode 14; 17; 18; 20
Bytecodes 14; 15; 17; 18; 19; 73
C
C 7; 9; 11; 12; 15; 17; 22; 23; 24; 25; 27;
28; 29; 30; 32; 33; 35; 42; 43; 45; 46; 47;
48; 52; 54; 74; 75; 77; 78; 79
C++ 7; 9; 11; 12; 15; 17; 22; 23; 24; 25; 28;
32; 33; 42; 48; 52; 54; 75; 77; 78; 79
Canvas 63
case 32; 33; 34
cast 34
catch 34; 36; 37
char 25; 32; 34; 79; 80
© J.-P. Thomsen 1996
Checkbox 63
class 14; 22; 34; 39; 42; 44; 46; 47; 49; 55;
58; 59; 60; 61; 66; 68; 73; 74; 79
Class Disassembler 74
Client 21; 67; 69
Compiler 24; 37; 45; 46; 52; 73; 76
const 34; 79; 80
Container 63; 64; 65
continue 23; 33; 34; 36
Cosmo Code 75
D
DataInputStream 66
Datenkapselung 53
Datenpaket 68; 69
Datentyp 25; 32; 42; 79
Datentypen 12; 13; 15; 23; 24; 25; 26; 27;
31; 32; 45; 79
Datenzugriff 54
Debugger 74
default 32; 33; 34; 53; 54
Dereferenzierung 26; 27
destroy() 58
Dialog 63; 66
disable() 64
do 32; 34; 67
Dokumentation 79
double 25; 34; 42; 43; 44; 46; 47; 50; 51;
55; 79
E
Eingabe 65; 66
Einschränkung 71
Einschränkungen 8; 70; 71; 72
else 32; 34; 47; 61
empfangen 59; 68; 69; 70
enable() 64
Endklasse 49
Entwicklungsumgebung 76; 77; 78
Entwicklungswerkzeug 76
Ereignis 60; 61; 64
Exception 35; 37; 68
extends 34; 49; 58; 59; 61; 66; 79
28.10.96 15:53
Tutorial
90
G Stichwortverzeichnis
F
J
FileDialog 63
Filter 66
FilterInputStream 66
final 34; 46; 49; 52; 55; 59; 66; 68
Finalizer 52
finally 34; 36
Firewall 19; 85
float 25; 34; 79
for 32; 33; 34; 62; 82; 84
Frame 62; 63
future 34
Jagg 75
Jamba 76
Java Development Kit 20; 40; 73
Java Workshop 77
java.applet 41; 58; 59; 61; 70
java.awt 27; 40; 58; 59; 61
java.io 40; 65; 66; 68
java.lang 35; 40; 49
java.net 40; 68; 70; 71
java.util 40
javac 58; 73
javadoc 73
javah 74
javap 74
JavaScript 20; 21
jdb 74
JDK 20; 40; 73; 75; 77; 84
JFactory 76
G
Garbage Collection 28; 80
Garbage Collector 12; 28; 29; 48
Geheimhaltung 53
generic 34
goto 23; 34
Graphical User Interface 62
Graphik 35; 57
GUI 34; 40; 62; 78
H
handleEvent (Event e) 65
handleEvent() 60
Header 12; 22; 74
Host 19; 70; 71; 85
HotJava 8; 10; 11
Hyperwire 75
K
Kawa 78
keyDown (Event e, int key) 65
Klasse 12; 13; 20; 22; 23; 24; 27; 28; 30;
31; 35; 37; 38; 40; 42; 43; 44; 45; 46; 47;
48; 49; 50; 51; 52; 53; 54; 55; 60; 61; 62;
63; 64; 65; 66; 67; 68; 69; 73; 74
Klassenhierarchie 12; 49; 50; 51
Klassenmethode 47; 48
Klassenvariable 46
Kommentar 25; 74
Konstante 27
Konstruktor 27; 44; 45; 48; 50; 51; 69
Kopie 26; 45; 66; 74
I
if 32; 33; 34; 37; 47; 61; 68
Imagemap 61
implements 34; 79
import 34; 40; 58; 59; 61; 66; 68; 79
init() 38; 57; 58; 59; 60; 61
Initialisierung 27; 29; 33; 43; 44; 48; 59;
61; 69
inner 34
instanceof 31; 34
Instanzenmethode 47
int 24; 25; 27; 29; 30; 32; 33; 34; 46; 59; 64;
65; 68; 79; 80
Interface 10; 26; 27; 38; 55; 56; 62; 81
Internet 7; 8; 10; 14; 17; 40; 67; 68; 69; 81;
83; 84; 85; 86
Interpreter 13; 15; 52; 73; 74
© J.-P. Thomsen 1996
L
Label 32; 33; 63
Latte 78
List 63
long 25; 32; 34; 79
M
mehrfach 35
Mehrfachvererbung 13; 23; 55
Methode 26; 27; 30; 34; 35; 36; 38; 39; 43;
44; 45; 46; 48; 49; 50; 51; 52; 53; 54; 55;
56; 58; 60; 61; 62; 66; 67; 68; 69; 70
minimumSize() 65
Modifier 53
Monitor 35; 38
mouseDrag (Event e, int x, int y) 65
mouseExit (Event e, int x, int y) 64
28.10.96 15:53
Tutorial
G Stichwortverzeichnis
mouseMove (Event e, int x, int y) 64
Müllabfuhr 12; 28; 48
Multithreading 14
N
native 15; 34
Native Method C File Generator 74
NetDynamics 76
new 26; 27; 28; 29; 34; 37; 42; 43; 44; 47;
48; 59; 61; 68
None 19
notify() 39
notifyAll() 39
null 26; 27; 29; 34; 67; 79
Nutmeg 76
O
Oberklasse 49; 51; 52; 53; 54; 60; 61
Objektmethoden 43
OEW 78
Operator 23; 26; 27; 28; 30; 31; 32; 34; 43;
79
Operator Overloading 23
Optima++ 78
outer 34
P
package 34; 40; 53; 71
paint(Graphics g) 58; 59; 64
Panel 63
Pipe 67
Pointer 13; 23; 24; 26; 28
Port 68; 69
Präprozessor 12; 46
preferredSize() 65
Priorität 38; 39; 48
private 34; 52; 53; 54; 59; 61; 74
private protected 53
protected 34; 53; 54; 74
public 34; 37; 42; 44; 46; 47; 49; 50; 51;
53; 54; 55; 58; 59; 61; 66; 68; 70; 72; 79
91
S
Schlüsselwort 27; 28; 29; 39; 42; 43; 44;
45; 46; 47; 49; 51; 52; 55; 79
Schnittstelle 67
Scrollbar 63
senden 67; 68; 70
Server 67; 69; 70; 71; 75; 76; 86
setLayout(LayoutManager I) 65
short 25; 32; 34; 79
show() 64
Sicherheit 20; 71
Sichtbarkeit 53; 54
size() 64
Socket 68; 69
Sockets 69; 70
Sound 62; 72
star seven 10
start() 38; 57; 62
static 22; 34; 45; 46; 47; 52; 55; 59; 68
stop() 38; 58
super 34; 51; 52; 53; 60; 61
switch 32; 33; 34; 60
Symantec Café 77
synchronized 34; 35; 38; 39; 80
T
TextArea 63; 66
Textfield 63
this 34; 43; 44; 46; 47; 50; 51; 61; 66
Thread 14; 34; 38; 39; 48; 58; 62; 69; 80
throw 34; 37
throws 34; 66; 68
transient 34
try 34; 36
Typenumwandlung 12; 23
U
Unrestricted 20
Unterklasse 35; 36; 49; 50; 51; 52; 54; 55
Unterklassen 50; 54
update(Graphics g) 64
URL 40; 67; 73; 86
R
V
Referenz 26; 27; 28; 42; 47
Referenzierung 26
repaint() 64
rest 34
return 34; 36; 42; 44; 46; 47; 59; 61; 67
Roaster 78
Rückgabewert 44; 48
var 34
Variable 26; 27; 28; 42; 43; 45; 46
Variablen 18; 21; 25; 26; 27; 33; 42; 43;
45; 46; 49; 50; 53; 54; 55
Vererbung 12; 21; 24; 49; 56
Verifizierung 13; 18; 19
Verifizierungsprozess 19
Verkettung 31; 51; 52
© J.-P. Thomsen 1996
28.10.96 15:53
Tutorial
92
G Stichwortverzeichnis
virtuelle Maschine 20
Visual J++ 77
void 34; 44; 55; 58; 59; 61; 64; 65; 68
volatile 34
World Wide Web 7; 9; 10; 20; 82; 85; 86
WWW 7; 67; 86
Z
W
wait() 39
WebRunner 10
while 32; 34; 62; 67
© J.-P. Thomsen 1996
Zeichenkette 27
zeichnen 64
Zeigerarithmetik 12
Zustände eines Threads 38
28.10.96 15:53
Tutorial
G Stichwortverzeichnis
© J.-P. Thomsen 1996
93
28.10.96 15:53