TUTORIAL

18.01
Untersuchen der
Programmiersprache Java
und entwickeln von Demo-
Applikationen 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:53Java - 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:53Java - 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:53Java - 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 IMAGEM