Einführung in die Programmiersprache JAVA

G. KAMLEITER
INFORMATIK
Kurs 12/13 (gk)
Einführung in JAVA
SJ 2004/05
LGG * DARMSTADT
Html, JavaScript und Java
- 1 -
15. Februar 2005 / 17:55:47
Inhaltsverzeichnis
I HTML-Grundlagen........................................................................................................................................................... 4
II JavaScript in HTML........................................................................................................................................................ 5
II.1 Was ist JAVASCRIPT?.......................................................................................................................................... 5
II.2 Ein Beispiel............................................................................................................................................................. 5
II.3 Ein zweites Beispiel................................................................................................................................................ 5
II.4 Einbau von JAVASCRIPT in HTML..................................................................................................................... 6
II.5 JavaScript in Links:................................................................................................................................................. 8
II.6 Grundlegende Sprachelemente in JavaScript.......................................................................................................... 8
II.6.1 Berechnungs-Operatoren.............................................................................................................................. 10
II.6.2 Zuweisungs-Operatoren................................................................................................................................10
II.6.3 Vergleichs-Operatoren..................................................................................................................................10
II.6.4 Logische Operatoren.....................................................................................................................................10
II.7 JavaScript bei Ereignissen (Event-Handler):.........................................................................................................11
II.7.1 Event-Handler...............................................................................................................................................11
II.7.2 Liste der Event-Handler in JavaScript..........................................................................................................11
II.8 Sieben Beispiele.................................................................................................................................................... 13
II.9 Formulare.............................................................................................................................................................. 15
II.10 Grafik.................................................................................................................................................................. 19
II.11 Aufgaben (Projekte):........................................................................................................................................... 19
III Einführung in JAVA..................................................................................................................................................... 21
III.1 Was ist JAVA?.....................................................................................................................................................21
III.2 Eigenschaften von JAVA.....................................................................................................................................21
III.3 Installation SDK...................................................................................................................................................22
III.4 Erste Gehversuche................................................................................................................................................25
III.5 JAVA Entwicklungszyklus in Kurzform..............................................................................................................26
III.6 Tipps und Vereinbarungen ..................................................................................................................................27
III.6.1 Formatierung der Quelltexte ...................................................................................................................... 27
III.6.2 Namenskonventionen.................................................................................................................................. 28
III.6.3 Aufruf von Java-Programmen unter Windows ...........................................................................................28
III.6.4 Erstellen einer Batchdatei ...........................................................................................................................29
III.6.5 Erstellen einer Verknüpfung auf dem Desktop .......................................................................................... 29
III.6.6 Verwenden von javaw anstelle von java .................................................................................................... 29
III.6.7 Troubleshooting ......................................................................................................................................... 29
III.6.7.1 Was ist eine DOS-Box und wie startet man sie? ............................................................................... 29
III.6.7.2 java läuft, javac aber nicht .................................................................................................................30
III.6.7.3 Was sind eigentlich Umgebungsvariablen? ....................................................................................... 30
III.6.7.4 Der Compiler javac arbeitet nicht ......................................................................................................30
III.6.7.5 Der Interpreter java arbeitet nicht korrekt ......................................................................................... 31
III.6.7.6 Zusätzlich benötigte Klassen werden nicht gefunden ........................................................................31
III.7 Konsolenanwendungen........................................................................................................................................ 32
III.7.1 Grundstruktur eines JAVA-Programms...................................................................................................... 32
III.7.2 Imperative und objektorientierte Programmiersprachen............................................................................. 33
III.8 Objektorientierte Programmierung...................................................................................................................... 34
III.8.1 Pakete und Klassen von Java.......................................................................................................................35
III.8.2 JAVA Sprachelemente................................................................................................................................ 36
III.8.2.1 Schlüsselwörter .................................................................................................................................36
III.8.2.2 Datentypen..........................................................................................................................................36
Html, JavaScript und Java
- 2 -
15. Februar 2005 / 17:55:48
III.8.2.3 Variablen............................................................................................................................................ 37
III.8.2.4 Verzweigungen (If/else, Switch, Case)...............................................................................................38
III.8.2.5 Die FOR-Schleife............................................................................................................................... 39
III.8.2.6 While und Do...while Schleife............................................................................................................39
III.8.3 I/O-Erweiterung...........................................................................................................................................40
III.9 Grafische Oberflächen / GUI Programmierung................................................................................................... 41
III.9.1 AWT und SWING .....................................................................................................................................41
III.9.2 Bilder laden und ausgeben.......................................................................................................................... 41
III.9.3 Das Grundgerüst einer grafischen Benutzeroberfläche............................................................................... 42
III.9.3.1 Umfangreicheres Beispiel (Telefon)...................................................................................................43
III.9.3.2 Text in Grafikfenstern.........................................................................................................................45
III.9.3.3 Fonts ................................................................................................................................................. 46
III.9.3.4 Elementare Grafikroutinen ................................................................................................................ 47
III.10 JAVA und SOUND............................................................................................................................................49
III.11 Applets............................................................................................................................................................... 50
III.11.1 Applet-Grundgerüst...................................................................................................................................50
III.11.2Lebenszyklus eines Applets........................................................................................................................ 51
III.11.3Das Arbeiten mit Parametern bei Applets................................................................................................... 51
III.11.4 Das Event-Modell über Listener ............................................................................................................ 52
III.11.5 Sound mit der Klasse Applet.....................................................................................................................53
III.12 Klassen programmieren ................................................................................................................................... 54
IV Datenbankprogrammierung.......................................................................................................................................... 57
V Netzwerkprogrammierung............................................................................................................................................. 57
VI Glossar..........................................................................................................................................................................57
VII Beispiel-Programme (Java applications) ..................................................................................................................64
VIII Beispiel-Programme (Java-Applets) .....................................................................................................................66
IX Referenzen....................................................................................................................................................................67
Html, JavaScript und Java
- 3 -
15. Februar 2005 / 17:55:48
I HTML-Grundlagen
Hypertext Markup Language ist eine Auszeichnungssprache für Dokumente im world-wide Web (WWW). Diese
Dokumente haben kein spezielles Dateiformat, sondern sind einfacher ASCII-Text. Deshalb können sie auf allen
Plattformen (Windows, Unix, Linux, Apple,...) verwendet werden und lassen sich von einfachen ASCII-Editoren
erstellen. Zur Darstellung der HTML-Seiten benötigt man einen Browser (Viewer), er interpretiert die Steuerzeichen,
auch TAGs genannt, die zwischen spitzen Klammern (<...>) stehen und stellt den Text entsprechend dieser
Steuerzeichen dar. Browser sind z.B. Internet-Explorer, Netscape, Mozilla, ...
Beispiel
<h4>HTML - die Sprache des WWW</h4>
Tags können ineinander verschachtelt werden.
Beispiel
<h4><i>HTML</i> - die Sprache des WWW</h4>
Ein HTML-Dokument hat grundsätzlich folgende Struktur:
<HTML>
<HEAD>
<TITLE>...</TITLE>
</HEAD>
<BODY>
:
:
</BODY>
</HTML>
Das <HTML>-Tag bezeichnet das gesamte Dokument, das <HEAD> -Element enthält Informationen über die Seite und
im <BODY> befindet sich der eigentliche Inhalt der Seite. Wichtigste Information im Kopfteil ist der Inhalt des
<TITLE>, der meist in de Kopfzeile des Browsers erscheint.
Kommentare erscheinen nicht auf dem Bildschirm und werden folgendermaßen geschrieben:

HTML hat grundsätzlich bis auf wenige Ausnahmen paarige TAGs, also immer Start und Ende-TAGs.
Spezielle TAGs zur Formatierung des Textes und der Bilder sind u.a.:
•
•
•
•
•
•
•
•
•
•
Html, JavaScript und Java
Farben von Hintergrund und Schriftzeichen
Größe, Art und Stil der Schrift
Einbau von Grafiken/Abbildungen
Überschriften erstellen und ausrichten
Nummerierungen, Aufzählungen
Tabellen
Links(Verweise)
Frames(Rahmen)
Musik(Sound)- und Video-Dateien
Animationen
- 4 -
15. Februar 2005 / 17:55:48
II JavaScript in HTML
II.1 Was ist JAVASCRIPT?
JavaScript ist eine von Netscape entwickelte Programmiersprache. JavaScript ist eine unmittelbare Ergänzung und
Erweiterung zu HTML.
Insbesondere ist JavaScript geeignet für folgende Zwecke:
•
Animation
•
Dynamische WWW-Seiten
•
Formulare
•
Programmieren einfacher Anwendungen
Der JavaScript-Code wird dabei clientseitig im Browser interpretiert und ausgeführt.
II.2 Ein Beispiel
<HTML>
<HEAD>
<TITLE>document.write()</TITLE>
</HEAD>
<BODY>
<H3>Alle ungeraden Zahlen kleiner als 10</H3>
<SCRIPT LANGUAGE="JavaScript"><!-var rest
for (var i=1; i<10; i++){
rest = i % 2
if (rest=1)
document.write(i+" ist ungerade!"+"<"+"BR"+">")
}
//--></SCRIPT>
</BODY>
</HTML>
Ausgabe:
Alle ungeraden Zahlen kleiner als 10
1 ist ungerade!
2 ist ungerade!
3 ist ungerade!
4 ist ungerade!
5 ist ungerade!
6 ist ungerade!
7 ist ungerade!
8 ist ungerade!
9 ist ungerade!
Der Fehler für die falsche Ausgabe ist in Zeile 11 zu suchen. Der Vergleich rest=1 muss richtig lauten rest= =1. Alle
Vergleiche erfolgen in javaScript mit doppeltem Gleichheitszeichen. In JavaScript ist der Strichpunkt optional und wird
nur gebraucht, wenn man mehr als eine Anweisung auf eine Zeile schreibt.
II.3 Ein zweites Beispiel
Es soll auf der Homepage eine Dialogbox erscheinen mit zwei Schaltflächen ( OK und Abbrechen).
Der Code ist relativ simpel. Nach dem HTML-Tag <SCRIPT LANGUAGE="JavaScript">
folgt der Kern dieses JavaScripts. Durch function dialog () wird eine Funktion definiert, die den namen dialog trägt. Es
folgt die geöffnete geschweifte Klammer {, dann der eigentliche Kern der Funktion
confirm ("Sie betreten meine Homepage");
Html, JavaScript und Java
- 5 -
15. Februar 2005 / 17:55:48
confirm erzeugt die vordefinierte Dialogbox. Sie enthält den OK-Knopf, ein Ausrufezeichen und den Abbrechen-Knopf.
In Klammern folgt der Text, der in der Dialogbox angegeben wird. Abgeschlossen wird die Zeile mit einem Semikolon.
Abgeschlossen wird die Funktion mit einer geschlossenen geschweiften Klammer. Alles was innerhalb der geschweiften
Klammern steht, gehört zur Funktion dialog.
Dann schließt der HTML-Befehl </SCRIPT> an, der das JavaScript beendet.
Jetzt muß das JavaScript noch gestartet werden; dies geschieht im <Body->Tag
<BODY onload="dialog ()">
Dort steht der Eventhandler onload und in Anführungszeichen die Funktion, die aufgerufen wird.
Es wäre nun sinnvoll, die beiden Schaltflächen mit einer Funktion zu belegen. Drückt der Internet-Surfer auf OK, wird
die eigentliche Homepage aufgerufen, klickt er auf Abbrechen, so bleibt er auf dieser ersten Dialogbox-Seite.
Beispiel
<HTML>
<HEAD> <TITLE> Homepage </TITLE> </HEAD>
<SCRIPT LANGUAGE="JavaScript">
function dialog ()
{
var Eingabe;
Eingabe=confirm ("Sie betreten meine Homepage");
if (Eingabe==true)
{
window.open("popp.html");
}
}
</Script>
<BODY onload="dialog ()">
..
</BODY> </HTML>
Die Änderungen befinden sich in der Funktion dialog
Gleich nach der geöffneten geschweiften Klammer wird über die Zeile
var Eingabe;
eine Variable definiert. var ist das Schlüsselwort zur Definition einer Variablen, danach folgt der Name der Variablen
Eingabe.
Hat der Internet-Surfer eine dieser zwei Schaltflächen gedrückt liefert die confirm-Anwendung das Ergebnis zurück.
Und zwar true, falls auf OK gedrückt wurde und false, wenn Abbrechen gedrückt wurde. Dies wird als Rückgabewert
bezeichnet.
Im nächsten Schritt muss entschieden werden, was passieren soll.
Wurde OK geklickt, soll eine neue Web-Seite aufgerufen werden. Also wenn die Variable den Wert true hat, soll die
neue Seite aufgerufen werden.
Dies wird über die if-Abfrage realisiert, die sich gleich nach confirm anschließt:
if (Eingabe==true)
{
window.open("popp.html");
}
Zuerst steht die if-Anfrage: Wenn (if) die Variable Eingabe den Wert true hat (Eingabe==true), dann soll was
passieren.
Es wird eine neue geschweifte Klammer geöffnet als Zeichen dafür, dass ein weiterer Block beginnt.
Danach folgt ein neuer Befehl: window.open("popp.html").
window.open offnet ein neues Browser-Fenster. D. h. es wird ein zweiter Web-Browser neben dem ersten erzeugt und in
diesem zweiten Browser-Fenster wird eine neue Web-Seite geladen (popp.html)
Die Funktion dialog wird mit der geschweiften Klammer geschlossen.
II.4 Einbau von JAVASCRIPT in HTML
Javascript-Programme werden werden direkt in die HTML-Datei eingefügt. Sie werden nicht wie in JAVA compiliert,
sondern als Quelltext zur Laufzeit interpretiert.
Html, JavaScript und Java
- 6 -
15. Februar 2005 / 17:55:48
Nachteile/Schwierigkeiten:
•
Javascript ist langsam und sollte daher nur für kleine und einfache
Programmabläufe verwendet werden.
•
Es findet keine Fehlerprüfungs statt; daher existiert auch kein Schutz vor
schweren Programmfehlern, z.B. Endlosschleifen.
•
Alte Browser können den Javascript-Text nicht interpretieren und geben ihn
als Text aus
•
Im Browser kann die Darstellung von Javascript-Texten deaktiviert werden
Um zu verhindern, dass der Javascript-Text als Text dargestellt wird, gibt es
die Möglichkeit <noscript> zu verwenden.
Beispiel:
<html>
<head>
<title>Alte Browser</title>
<script language="JavaScript"><!-document.write("Herzlich willkommen!");
//--></script>
</head>
<body>
</body>
</html>
Der <noscript> Container wird auch von Browsern mit deaktiviertem Javascript
ausgewertet und ausgegeben:
<html>
<head>
<title>noscript</title>
<script language="JavaScript"><!-document.write("Herzlich willkommen!");
//--></script>
</head>
<body>
<noscript>
Ihr Browser kann kein JavaScript
</noscript>
</body>
</html>
Position des Scriptbereiches:
Ein <script>-Bereich kann an der Stelle im HTML-Text stehen, an der die Ausgabe
erfolgen soll.
<html>
<head>
<title>Skript in Head und Body</title>
<script language="JavaScript"><!-document.write("Herzlich willkommen!");
//--></script>
</head>
<body>
<script language="JavaScript"><!-document.write("Noch einmal herzlich willkommen!");
//--></script>
</body>
</html>
Html, JavaScript und Java
- 7 -
15. Februar 2005 / 17:55:49
Kurzform:
Eine Zeile reicht allerdings für die Kurzform des Script-Containers aus:
<script>document.write("Hallo");</script>
Externes JavaScript:
Ein JavaScript-Code lässt sich auch als externe Datei speichern. Sie hat die Dateiendung .js Im externen Script werden
nur die JavaScript-Befehle gespeichert:
document.write("Hallo!");
Der Aufruf des externen Scripts erfolgt mit dem Attribut src relativ oder absolut.
<script src="skriptname.js" language="JavaScript">
II.5 JavaScript in Links:
Auch in Links kann JavaScriptcode eingebettet werden:
<html>
<head>
<title>JavaScript in Links</title>
</head>
<body>
<a href="javascript:document.write('Text im Link');">
Bitte Klicken</a>
</body>
</html>
II.6 Grundlegende Sprachelemente in JavaScript
Bezeichner:
javaScript unterscheidet zwischen Groß- und Kleinschreibung. Dies gilt nicht nur bei Variablennamen sondern auch bei
Funktionsnamen und Objekten!
Ein Variablenname beginnt mit einem Buchstaben oder dem Unterstreichungsstrich . Ansonsten darf er aus Buchstaben,
Zahlen und dem Unterstreichungsstrich bestehen. Sonderzeichen sind in Variablennamen nicht erlaubt. Auch die
verwendung reservierter Schlüsselwörter ist nicht erlaubt. JavaScript ignoriert Leerzeichen und Tabulatoren. Sie können
für die Formatierung der Skripten genutzt werden.
Datentypen:
JavaScript unterscheidet folgende DatenTypen:
•
Integer
•
Gleitkommazahlen (Float)
•
Exponentialschreibweise (9e+20)
•
Zeichenketten (strings)
•
Boolean (true oder false)
•
arrays
•
Funktionen
•
Objects (Objekte)
Escape Sequenzen:
Eine besondere Rolle spielen Escape-Sequenzen, d.i. Ein Backslash \ mit einem nachsgestellten Zeichen.
Html, JavaScript und Java
- 8 -
15. Februar 2005 / 17:55:49
\0
\b
\f
\n
\r
\t
\\
Nullzeichen terminiert den strings
backspace
Seitenvorschub
Zeilenumbruch
Wagenrücklauf
Tabulatoren
gibt einen Backslash aus
Zeichensatz:
In neueren Browsern unterstützt javaScript den kompletten Unicode-Zeichensatz. Der unicode zeichensatz hat eine
Tiefe von 16 Bit und unterstützt die meisten Sprachen der Welt. Ein Zeichen wird wie folgt notiert:
uAAAA AAAA staht dabei für die hexadezimale Zahl des Unicode-Zeichens.
Typkonvertierung:
JavaScript konvertiert Datentypen von Variablen automatisch.
Var x = „drei“;
x=3;
Zuerst wird die Variable x als Datentyp String initialisiert. Anschließend wird ihr ein Integer zugewiesen. Die
Typkonvertierung von String in Zahl geschieht automatisch. Mit den Funktionen
•
Element.toString()
•
Number(String)
•
parseFloat(String)
•
parseInt(String)
können zusätzliche Umwandlungen ausgeführt werden.
Kommentare:
JavaScript unterstützt einzeilige und mehrzeilige Kommentare.
//
Ab der Stelle, wo das zeichen eingefügt ist, wird der Text oder Code entwertet
/* * /
mehrzeilige Kommentare werden in /*
*/ eingeschlossen
Konstanten:
Konstanten sind einmal fest definierte Werte und werden mit dem Schlüsselwort const eingeleitet.
Ein- und Ausgaben:
Für die verschiedenen Ein- und Ausgaben gibt es folgende Möglichkeiten (s.a. Beispiele unten)
document.write() Bspl: document.write(i*t+“<br />“);
alert()
Bspl.: window.alert(„Die Funktion gibt etwas aus!“);
prompt()
Bspl.: var x=window.prompt(„Erste Zahl?“,““); allg. window.prompt(Beschreibung, Voreinstellung)
input
Bspl.: <input type=“text“ name=“dec />
confirm
Bspl.: var erg=window.confirm(„haben Sie einen Führerschein?“);
Besondere Operatoren:
Html, JavaScript und Java
- 9 -
15. Februar 2005 / 17:55:49
II.6.1 Berechnungs-Operatoren
Operator
+
Beschreibung
Addition
Beispiel
x=2
x+2
Resultat
4
-
Subtraktion
x=2
5-x
3
*
Multiplikation
x=4
x*5
20
/
Division
15/5
5/2
3
2.5
%
Modulo (Restwert bei einer Division)
5%2
10%8
10%2
1
2
0
++
Inkrement
x=5
x++
x=6
--
Dekrement
x=5
x--
x=4
II.6.2 Zuweisungs-Operatoren
Operator
=
Beschreibung
Wertzuweisung
Beispiel
x=5
Resultat
x enthält 5
+=
Addition und Zuweisung
x+=5 oder x=x+5
x enthält 10
-=
Subtraktion und Zuweisung
x-=2 oder x=x-2
x enthält 8
*=
Multiplikation und Zuweisung
x*=2 oder x=x*2
x enthält 16
/=
Division und Zuweisung
x/=4 oder x=x/4
x enthält 4
%=
Modulo-Operation und Zuweisung
x%=3 oder x=x%3
x enthält 1
II.6.3 Vergleichs-Operatoren
Operator
==
Beschreibung
Werte sind gleich
Beispiel
5==8 ergibt false
!=
Werte sind ungleich
5!=8 ergibt true
>
linker Wert ist grösser
5>8 ergibt false
<
linker Wert ist kleiner
5<8 ergibt true
>=
ist grösser oder gleich
5>=8 ergibt false
<=
ist kleiner oder gleich
5<=8 ergibz true
II.6.4 Logische Operatoren
Operator
&&
Beschreibung
und
Beispiel
x=6
y=3
(x < 10 && y > 1) ergibt true
||
oder
!
nicht
x=6
y=3
(x==5 || y==5) ergibt false
!true ergibt false
!false ergibt true
Kehrt den Wert um!
Html, JavaScript und Java
- 10 -
15. Februar 2005 / 17:55:49
II.7 JavaScript bei Ereignissen (Event-Handler):
Auch mit Hilfe eines Event-Handlers (Ereignisbehandlungsroutine) lässt sich
JavaScript-Code aufrufen und ausführen. Ein Event-Handler ist ein HTML-Attribut.
Er beginnt immer mit on , dann folgt der Name des Ereignisses: onclick steht
also für einen Mausklick, onmouseover für das Überfahren eines Objektes mit der
Maus. Event-Handler können in verschiedene Tags eingebaut werden. Eine der
häufigsten Einsatzgebiete sind Links:
<html>
<head>
<title>Event-Handler</title>
</head>
<body>
<a href="seite2.html" onclick="alert('Herzlich Willkommen');">
Bitte Klicken</a>
</body>
</html>
II.7.1 Event-Handler
Event-Handler sind die Schnittstelle zwischen HTML-Datei und JavaScript-Code. Erst mit Hilfe von Event-Handlern ist
es beispielsweise möglich, einen Befehl wie "Zeige in der Statuszeile Text X an, wenn der Anwender mit der Maus über
den Verweis fährt" zu realisieren.
Beispiel
<body onLoad="PruefeAnwenderIntelligenz()">
Alle Event-Handler beginnen mit on.... Der Event-Handler onLoad bedeutet beispielsweise so viel wie "beim Laden".
Event-Handler stehen immer innerhalb von HTML-Tags. Welche Event-Handler in welchen HTML-Tags stehen
können, wird weiter unten in der Liste der Event-Handler beschrieben. Event-Handler werden genau so notiert wie
gewöhnliche Zusatzangaben in HTML-Tags. Hinter dem Namen des Event-Handlers fogt ohne Leerzeichen
dazwischen ein Istgleichzeichen. Dahinter folgt, in Anführungszeichen eingeschlossen, der JavaScript-Befehl, der "bei
Eintritt des Ereignisses" aufgerufen werden soll. In den meisten Fällen ist dies - wie auch in den Beispielen oben - der
Aufruf einer Funktion, die in der gleichen HTML-Datei innerhalb von <script language="JavaScript"> bzw.
</script> definiert ist.
II.7.2 Liste der Event-Handler in JavaScript
onBlur:
Dieser Event-Handler bedeutet so viel wie "beim Verlassen" und kann innerhalb von Formularen folgenden HTMLTags vorkommen:
•in Eingabefeldern: <input type="text" ... onBlur="..."> (z.B. zum Überprüfen von Eingaben)
•in mehrzeiligen Eingabefeldern: <textarea ... onBlur="..."> (z.B. zum Überprüfen von Eingaben)
•in Auswahllisten: <select ... onBlur="..."> (z.B. zum Kommentieren der getroffenen Auswahl)
onChange:
Dieser Event-Handler bedeutet so viel wie "bei Verlassen und geändertem Wert" und kann innerhalb von Formularen
folgenden HTML-Tags vorkommen:
•in Eingabefeldern: <input type="text" ... onChange="..."> (z.B. zum Überprüfen von Eingaben)
•in mehrzeiligen Eingabefeldern: <textarea ... onChange="..."> (z.B. zum Überprüfen von Eingaben)
•in Auswahllisten: <select ... onChange="..."> (z.B. zum Kommentieren der getroffenen Auswahl)
onClick:
Dieser Event-Handler bedeutet so viel wie "beim Anklicken" und kann innerhalb von Verweisen und Formularen in
folgenden HTML-Tags vorkommen:
•in Verweisen: <a href="" ... onClick="..."> (Hierbei ist in der Regel jedoch das spezielle Handling bei
Verweisen vorzuziehen)
Html, JavaScript und Java
- 11 -
15. Februar 2005 / 17:55:49
•bei frei definierbaren Buttons: <input type="button" ... onClick="..."> (z.B. zum Aufruf mehrerer
Verweisziele gleichzeitig bei Frames)
•bei Radio- und Checkbuttons: <input type="radio" ... onClick="..."> oder <input type="checkbox" ...
onClick="..."> (z.B. zum Überprüfen der Eingaben)
•bei Ausführungsbuttons: <input type="submit" ... onClick="..."> oder <input type="reset" ... onClick="...">
(z.B. zum Bestätigen des Vorgangs)
onFocus:
Dieser Event-Handler bedeutet so viel wie "Bei Positionieren auf dieses Element" und kann innerhalb von Formularen
folgenden HTML-Tags vorkommen:
•in Eingabefeldern: <input type="text" ... onFocus="..."> (z.B. zum Kommentieren der Bedeutung des
Eingabefelds)
•in mehrzeiligen Eingabefeldern: <textarea ... onFocus="..."> (z.B. zum Kommentieren der Bedeutung des
Eingabefelds)
•in Auswahllisten: <select ... onChange="..."> (z.B. zum Kommentieren der Auswahlmöglichkeiten)
onLoad:
Dieser Event-Handler bedeutet so viel wie "Nach dem Laden" und kann beim Laden von HTML-Dateien folgenden
HTML-Tags vorkommen:
•in Dateikörper: <body ... onLoad="..."> (z.B. zum Ausgeben von aktuellem Datum und Uhrzeit beim Aufruf)
•in Frame-Sets: <frameset ... onLoad="..."> (z.B. zum Ausgeben von aktuellem Datum und Uhrzeit in einem
der Frames)
onMouseOver:
Dieser Event-Handler bedeutet so viel wie "beim Darüberfahren mit der Maus" und kann innerhalb von Verweisen in
folgendem HTML-Tag vorkommen:
•in Verweisen: <a href="" ... onMouseOver="..."> (z.B. zum Kommentieren des Verweisziels)
onSelect:
Dieser Event-Handler bedeutet so viel wie "beim Markieren von Text" und kann innerhalb von Formularen folgenden
HTML-Tags vorkommen:
•in Eingabefeldern: <input type="text" ... onSelect="..."> (derzeit kein Anwendungsbesipiel bekannt)
•in mehrzeiligen Eingabefeldern: <textarea ... onSelect="..."> (derzeit kein Anwendungsbesipiel bekannt)
onSubmit:
Dieser Event-Handler bedeutet so viel wie "beim Absenden" und kann bei Formularen in folgendem HTML-Tag
vorkommen:
•bei Formulardefinitionen: <form ... onSubmit="..."> (z.B. um eine Bestätigungsmeldung am Bildschirm
auszugeben)
onUnload:
Dieser Event-Handler bedeutet so viel wie "Nach dem Beenden" und kann beim Laden von HTML-Dateien folgenden
HTML-Tags vorkommen:
•in Dateikörper: <body ... onUnload="..."> (z.B. zum Ausgeben der Zeit, die der Anwender mit der WWWSeite zubrachte)
•in Frame-Sets: <frameset ... onUnload="..."> (z.B. zum Ausgeben der Zeit, die der Anwender mit der WWWSeite zubrachte)
Html, JavaScript und Java
- 12 -
15. Februar 2005 / 17:55:49
II.8 Sieben Beispiele
Beispiel 1: Funktion, Eingabe und event
<b><u>Beispiel:</u></b><br>
<html>
<head>
<title>Passwort</title>
<script language="JavaScript"><!-var pw = "JavaScript";
function pruefen() {
if (document.formular.pass.value == pw) {
document.write("Herzlich willkommen!");
} else {
alert("Nicht autorisiert!");
}
}
--></script>
</head>
<body>
<form name="formular">
<input type="password" name="pass" /><br />
<input type="button" value="Pr&uuml;fen" onclick="pruefen()" />
</form>
</body>
</html>
Beispiel 2: Ein- und Ausgabe mit prompt und alert
<TITLE>window.prompt()</TITLE>
<BODY>
<H3>What's your name?</H3>
<SCRIPT LANGUAGE="JavaScript"><!-var benutzername = prompt("Wie heißen Sie?")
if (benutzername)
alert("Guten Tag, Herr/Frau " + benutzername)
//--></SCRIPT>
</BODY>
Beispiel 3:
Event
<head>
<title>Event-Handler</title>
</head>
<body>
<a href="seite2.html" onclick="alert('Herzlich Willkommen');">
Bitte Klicken</a>
</body>
Beispiel 4: If Entscheidung
<head>
<title>else if-Anweisung</title>
</head>
<body>
<script language="JavaScript"><!-var z = 5;
if (z >= 5) {
document.write("Luxusnutzer");
Html, JavaScript und Java
- 13 -
15. Februar 2005 / 17:55:50
} else if (z >= 3) {
document.write("Mittelklasse");
} else if (z >= 1) {
document.write("Einsteigerpaket");
}
//--></script>
</body>
Beispiel 5: For Schleife
<script language="JavaScript"><!-for (var i=1; i <= 100; i++)
{
document.write(i + "<br />");
if (i == 12)
{
break;
}
}
//--></script>
Beispiel 6: switch-Anweisung
<head>
<title>switch</title>
</head>
<body>
<script language="JavaScript"><!-var tag = 3;
switch (tag) {
case 0:
document.write("Montag");
break;
case 1:
document.write("Dienstag");
break;
case 2:
document.write("Mittwoch");
break;
case 3:
document.write("Donnerstag");
break;
case 4:
document.write("Freitag");
break;
case 5:
document.write("Samstag");
break;
case 6:
document.write("Sonntag");
break;
}
//--></script>
</body>
Beispiel 7: this
Soll eine Funktion in einem event-handler aufgerufen werden und mit einem HTML-Element verknüpft werden, muss
sie das auftretende HTML-Element kennen. Dazu verwendet man das Schlüsselwort this, das das HTML-Element
liefert. Der Parameter kann innerhalb der Funktion als Variable verwendet werden.
<title>this</title>
Html, JavaScript und Java
- 14 -
15. Februar 2005 / 17:55:50
<script language="JavaScript"><!-function ausgabe(element) {
alert("Text im Feld: " + element.value);
}
//--></script>
</head>
<body>
<form>
<input type="text" onchange="ausgabe(this)" name="feld" />
</body>
II.9 Formulare
Durch HTML-Dokumente kann nicht nur Information wiedergegeben, sondern auch eingegeben werden. Zur Eingabe
stellt HTML sogenannte Formulare zur Verfügung, die der Benutzer entweder über die Tastatur oder mit Hilfe der Maus
ausfüllen kann. Die in ein Formular eingetragene Information kann dann zur Auswertung an einen Server geschickt
werden. Auf diese Weise ist es beispielsweise möglich, sich über das WWW für Veranstaltungen anzumelden oder
Produkte zu bestellen.
Ein HTML-Formular wird durch einen FORM-Tag definiert, der u.a. das optionale Attribut ACTION besitzt. Durch
dieses Attribut kann die URL des Servers angegeben werden, der für die Auswertung der übertragenen Daten zuständig
ist. Innerhalb des FORM-Start-Tags und des FORM-End-Tags werden mit weiteren Tags die Elemente festgelegt, die das
Formular enthalten soll.
Das wichtigste Formularelement wird durch den INPUT-Tag definiert. Die Ausprägung dieses Formularelements wird
durch das Attribut TYPE bestimmt, dem u.a. die Werte "BUTTON", "CHECKBOX", "PASSWORD", "RADIO",
"RESET", "SUBMIT" und "TEXT" zugewiesen werden können.
Ein Formularelement vom Typ BUTTON erzeugt im HTML-Formular eine Schaltfläche mit einer Beschriftung, die
durch das Attribut VALUE festgelegt werden kann. BUTTON-Elemente sind erst in Verbindung mit JavaScript sinnvoll,
da sie in HTML selbst keine Funktion haben.
<FORM>
<INPUT TYPE="BUTTON" VALUE="Schaltfläche 1">
<INPUT TYPE="BUTTON" VALUE="Schaltfläche 2">
<INPUT TYPE="BUTTON" VALUE="Schaltfläche 3">
</FORM>
Schaltfläche 1
Schaltfläche 2
Schaltfläche 3
Das Formularelement CHECKBOX erzeugt ein Kontrollkästchen im HTML-Formular, das mit der Maus selektiert
oder deselektiert werden kann. Über das Attribut CHECKED kann festgelegt werden, ob das Kontrollkästchen
vorausgewählt ist. Die Attribute NAME und VALUE bestimmen, welcher Name und welcher Wert dem Server übermittelt
wird, falls das Kontrollkästchen beim Abschicken des Formulars selektiert ist.
<FORM>
<INPUT TYPE="CHECKBOX" NAME="Kontrollkaestchen1" VALUE="1" CHECKED >
Kontrollk&auml;stchen 1<BR>
<INPUT TYPE="CHECKBOX" NAME="Kontrollkaestchen2" VALUE="2">
Kontrollk&auml;stchen 2<BR>
<INPUT TYPE="CHECKBOX" NAME="Kontrollkaestchen3" VALUE="3">
Kontrollk&auml;stchen 3<BR>
</FORM>
Kontrollkästchen 1
Kontrollkästchen 2
Kontrollkästchen 3
Html, JavaScript und Java
- 15 -
15. Februar 2005 / 17:55:50
Die Formularelemente PASSWORD und TEXT erzeugen beide ein einzeiliges Textelement, in das über die Tastatur
Text eingegeben werden kann. Die Attribute SIZE und MAXLENGTH legen die Breite des Textelements bzw. die
maximale Textlänge fest. Das PASSWORD-Element unterscheidet sich vom TEXT-Element dadurch, daß bei ihm die
eingegebenen Buchstaben nicht im Klartext, sondern als Sterne (*) wiedergegeben werden. (Dies geschieht, damit
unberechtigte Personen ein eingegebenes Kennwort nicht vom Bildschirm ablesen können. Allerdings werden die
Informationen über das Internet unverschlüsselt übertragen!)
<FORM>
Benutzername: <INPUT TYPE="TEXT" SIZE=8 MAXLENGTH=16><BR>
Kennwort: <INPUT TYPE="PASSWORD" SIZE=8 MAXLENGTH=16>
</FORM>
Benutzername:
Kennwort:
Das Formularelement RADIO (Optionsfeld) ähnelt dem Element CHECKBOX und hat wie dieses die Attribute
CHECKED, NAME und VALUE. Allerdings kann von allen zu einer Gruppe gehörenden RADIO-Elementen nur ein
einziges ausgewählt sein. Die Anwahl eines anderen Optionsfeldes bewirkt automatisch das Rücksetzen der anderen
Felder der Gruppe. Dabei gehören alle diejenigen Optionsfelder zu einer Gruppe, deren NAME-Attribut den gleichen
Wert besitzt.
<FORM>
</FORM>
<INPUT
<INPUT
<INPUT
<INPUT
<INPUT
<INPUT
TYPE="RADIO"
TYPE="RADIO"
TYPE="RADIO"
TYPE="RADIO"
TYPE="RADIO"
TYPE="RADIO"
NAME="GruppeA"
NAME="GruppeA"
NAME="GruppeA"
NAME="GruppeB"
NAME="GruppeB"
NAME="GruppeB"
VALUE="1" CHECKED>Option A1
VALUE="2">Option A2
VALUE="3">Option A3<BR>
VALUE="1">Option B1
VALUE="2">Option B2
VALUE="3" CHECKED>Option B3
Option A1 Option A2 Option A3
Option B1 Option B2 Option B3
Die Formularelemente RESET und SUBMIT erzeugen spezielle Schaltflächen, die, anders als die BUTTON-Elemente,
auch in HTML Funktionalität besitzen. Durch Anklicken der RESET-Schaltfläche wird das HTML-Formular in seinen
Ausgangszustand (dem Zustand nach dem Laden des Dokuments) versetzt, und durch Anwahl der SUBMIT-Schaltfläche
wird die in das Formular eingetragene Information an den im FORM-Tag spezifizierten Server geschickt. Die
Beschriftung der Schaltflächen kann wie beim BUTTON-Element durch das Attribut VALUE festgelegt werden.
<FORM ACTION="http://www.abc.de/">
Name: <INPUT TYPE="TEXT"><BR>
E-Mail: <INPUT TYPE="TEXT"><BR>
<INPUT TYPE="RESET" VALUE="Rücksetzen">
<INPUT TYPE="SUBMIT" VALUE="Abschicken">
</FORM>
Name:
E-Mail:
Rücksetzen
Abschicken
Neben dem INPUT-Tag können innerhalb von Formularen auch TEXTAREA- und SELECT-Tags stehen. Durch
TEXTAREA wird ein mehrzeiliges Textfeld realisiert. Die Zeilen- und die Spaltenzahl werden durch die Attribute
ROWS und COLS angegeben. SELECT erzeugt eine Auswahlliste, aus der Elemente selektiert werden können. Die
Html, JavaScript und Java
- 16 -
15. Februar 2005 / 17:55:50
Attribute MULTIPLE und SIZE legen fest, ob mehrere Elemente gleichzeitig ausgewählt sein können bzw. wieviele
Elemente gleichzeitig angezeigt werden. Innerhalb von SELECT-Start- und End-Tags werden die zur Auswahl
stehenden Elemente durch OPTION-Tags definiert. Diese Tags besitzen das Attribut SELECTED, das bestimmt, ob ein
Element nach dem Laden des Dokuments oder dem Drücken der RESET-Schaltfläche vorselektiert ist. Durch das
VALUE-Attribut kann den Optionselementen ein Wert zugeordnet werden, der bei angewählter Option beim Abschicken
des Formulars an den Server übertragen wird.
<FORM>

<TEXTAREA ROWS=5 COLS=40>
Ein Textfeld
</TEXTAREA><BR><BR>

<SELECT SIZE=1>
<OPTION VALUE="1">Option A1</OPTION>
<OPTION VALUE="2" SELECTED>Option A2</OPTION>
<OPTION VALUE="3">Option A3</OPTION>
<OPTION VALUE="4">Option A4</OPTION>
</SELECT>

<SELECT SIZE=3 MULTIPLE>
<OPTION VALUE="1" SELECTED>Option B1</OPTION>
<OPTION VALUE="2">Option B2</OPTION>
<OPTION VALUE="3" SELECTED>Option B3</OPTION>
<OPTION VALUE="4">Option B4</OPTION>
<OPTION VALUE="5">Option B5</OPTION>
</SELECT>
</FORM>
Ein Textfeld
Option A2
AUFGABE 1:
Option B1
Option B2
Option B3
Währungsrechner
Erstelle ein Programm mit JavaScript, das einen einzugebenden Währungsbetrag von Euro nach DM bzw. nach Auswahl
mit einer Checkbox von DM nach Euro berechnet und in einem Feld das Ergebnis ausgibt.
DM nach Euro |
Euro nach DM
Umrechnen!
Lösung:
<html>
<head>
<title>Euro-Rechner</title>
<script language="JavaScript"><!-function umrechnen(f){ //f ist eine Referenz auf das Formular
Html, JavaScript und Java
- 17 -
15. Februar 2005 / 17:55:50
var betrag = f.betrag.value
if (betrag.indexOf(",")!=-1)
betrag = betrag.substring(0, betrag.indexOf(",")) + "." + betrag.substring(betrag.indexOf(","), betrag.length)
if (f.umrechnung[0].checked)
f.ausgabe.value = 1.95583 * betrag
else
f.ausgabe.value = betrag / 1.95583
}
//--></script>
</head>
<body>
<form>
<input type="text" name="betrag"><br>
<input type="radio" name="umrechnung" value="DMEUR"> DM nach Euro | <input type="radio"
name="umrechnung" value="EURDM"> Euro nach DM<br>
<input type="button" value="Umrechnen!" onclick="umrechnen(this.form)"> <input type="text" name="ausgabe">
</form>
</body>
</html>
AUFGABE 2: Anmeldeformular
Erstelle ein Anmeldeformular der folgenden Form:
Vorname:
Nachname:
E-Mail-Adresse:
männlich | weiblich
Welche Bücher von Galileo Press besitzen Sie?
Flash | JavaScript | JavaScript-Rezepte
Welches der Bücher hat das schönste Cover?
Absenden
Bitte wählen
Formular löschen
Lösung:
<html>
<head>
<title>FormularÜbung</title>
<meta name="author" content="Guenther">
</head>
<body text="#000000" bgcolor="#FFFFFF" link="#FF0000" alink="#FF0000" vlink="#FF0000">
<h3>Anmeldeformular</h3>
<form name="Fragebogen">
Vorname: <input type="text" name="Vorname"><br>
Nachname: <input type="text" name="Nachname"><br>
E-Mail-Adresse: <input type="text" name="Email"><br>
<input type="radio" name="Geschlecht" value="m"> männlich |
<input type="radio" name="Geschlecht" value="w"> weiblich<br>
Welche Bücher von Galileo Press besitzen Sie?<br>
<input type="checkbox" name="Flash"> Flash |
<input type="checkbox" name="JavaScript"> JavaScript |
<input type="checkbox" name="Rezepte"> JavaScript-Rezepte<br>
Welches der Bücher hat das schönste Cover?
<select name="Cover">
<option>Bitte wählen</option>
<option value="Flash">Flash</option>
<option value="JavaScript">JavaScript</option>
Html, JavaScript und Java
- 18 -
15. Februar 2005 / 17:55:50
<option value="Rezepte">JavaScript-Rezepte</option>
</select><br>
<input type="submit" value="Absenden">
<input type="reset" value="Formular löschen">
</form>
</body>
</html>
II.10 Grafik
Browser unterstützen in der Regel nur Bitmap-Grafiken. In JavaScript werden Grafiken mit dem Image-Objekt
dargestellt. Dazu wird eine neue Instanz des Image-Objekts bei der objektorientierten Programmierung wie folgt erstellt:
var img = new Image();
Danach enrhält die Variable img ein Image Objekt und man muss noch die Eigenschaft src dieser Variablen der name
der Grafik zuordnen:
var img = new Image();
img.src = „grafik.png“;
Damit wird die Grafik angefordert und geladen.
Die Größe der Grafik kann als Parameter an new Image () übergeben werden, zunächst die Breite, dann die Höhe:
var img = new Image(150,200);
II.11 Aufgaben (Projekte):
Aufgabe 1:
Spielen Sie Reisebüro und bieten die Besichtigung von vier schönen Städten wie Bochum, Liverpool usw. in einer
Internet Site an. Dabei sollen neben Informationen zu den Städten auch Preise und Bilder mit eingebaut werden.
Aufgabe 2:
Konsul Herbert Herzlos, der Boß der Entenhausen U-Bahn AG, will Personal einsparen und seine netten
Schaltergänse durch seelenlose Automaten ersetzen und Sie sollen ihm bei seinem ruchlosen Vorhaben mit einem
Programm helfen. Da Sie vermutlich noch nie in Entenhausen U-Bahn gefahren sind, müssen Sie sich zunächst mit
den Tarifen vertraut machen. Sie erfahren durch hartnäckige Befragung folgendes:
·
Es gibt einen Kilometergrundpreis von 20 Kreuzern pro gefahrenen Kilometer.
·
Kinder bis 14 Jahren zahlen immer nur die Hälfte, andere Ermäßigungen gibt es nicht.
·
Rückfahrkarten kosten genau doppelt soviel wie einfache Fahrkarten.
·
Werden gleich 5 Fahrkarten gezogen, gibt es eine Fahrt umsonst, für 10 Fahrkarten sogar 3 Fahrten.
·
Es gibt nur vier Bahnhöfe: Hauptbahnhof, Emil Erpel Monument (EEM), Museum des ersten Talers (MET) und
Gundel Gaukeley Platz (GGG).
·
Die Entfernungen vom Hauptbahnhof zum Emil Erpel Monument, Museum des ersten Talers und Gundel
Gaukeley Gasse betragen 10, 12 und 6 km.
·
Der Fahrkartenautomat soll nur am Hauptbahnhof aufgestellt werden.
Präsident Herzlos möchte einen Automaten mit einfach zu bedienenden Steuerelementen, und zwar einer Listbox für
die Auswahl der Bahnhöfe, Checkboxen für die Angaben über Rück- bzw. Kinderfahrkarte und Optionsfelder für die
Auswahl der Anzahl von Fahrkarten. Der ausgewählte Bahnhof soll optisch als Bild erscheinen.
Aufgabe 3:
Lehrer Lempel hat einen LK in Mathematik (Thema Analysis II). Da er auch einige Grundkenntnisse in Informatik und
Html, JavaScript und Java
- 19 -
15. Februar 2005 / 17:55:51
hier insbesondere in Html und JavaScript hat, möchte er seinen Schülern aktuelle Informationen und die Lösungsblätter
seiner Mathematik-Übungen auf seiner Hompage ins Internet stellen. Zum Einstieg schwebt ihm folgende Eigenschaften
der Site vor:
•
Von einer Startseite soll auf eine passwortgeschützte Seite verzweigt werden. (Als Passwort soll „LKM12I“) dienen.
•
Auf der passwortgeschützten Seite sollen private Mitteilungen, die nicht jeden im Internet etwas angehen,
wie z.B. Kurstreffen, Tutandentreffen o.ä. angezeigt werden
•
auf einer weiteren Seite sollen die Lösungen des aktuellen Arbeitsblattes dargestellt werden. Da im
Moment Kurvendiskussionen angesagt sind werden zur Übung verschiedene Funktionsgleichungen
angeboten.
•
Fährt man mit dem MausCursor über diese Funktionsgleichungen, so soll der dazugehörige Graf in einem
Bild angezeigt werden.
•
Zum Testen der ganzen Site sollen die Funktionen
a)
b)
c)
d)
e)
verwendet werden.
Html, JavaScript und Java
- 20 -
15. Februar 2005 / 17:55:51
III Einführung in JAVA
III.1 Was ist JAVA?
Java wurde von der Firma Sun entwickelt und erstmals am 23. Mai 1995 als neue, objekt-orientierte, einfache und
plattformunabhängige Programmiersprache vorgestellt. Sun besitzt das Schutzrecht auf den Namen Java und stellt damit
sicher, daß nur "100 % richtiges Java" diesen Namen tragen darf. Die Sprache ist aber für alle Computersysteme
verfügbar (im Allgemeinen kostenlos).
Java geht auf die Sprache Oak zurück, die 1991 von Bill Joy, James Gosling und Mike Sheridan im Green-Projekt
entwickelt wurde, mit dem Ziel, eine einfache und plattformunabhängige Programmiersprache zu schaffen, mit der nicht
nur normale Computer wie Unix-Workstations, PCs und Apple programmiert werden können, sondern auch die in
Haushalts- oder Industriegeräten eingebauten Micro-Computer, wie z.B. in Waschmaschinen und Videorekordern,
Autos und Verkehrsampeln, Kreditkarten und Sicherheitssystemen und vor allem auch in TV-Settop-Boxes für
"intelligente" Fernsehapparate.
Allgemein anerkannt wurde Java aber erst seit 1996 in Verbindung mit Web-Browsern und Internet-Anwendungen
sowie mit der Idee eines NC (Network Computer), der im Gegensatz zum PC (Personal Computer) nicht lokal
installierte, maschinenspezifische Software-Programme benötigt, sondern die Software in Form von Java-Klassen
dynamisch über das Netz (Intranet) von einem zentralen Server laden kann. Diese Idee wurde später zu einem
allgemeinen "Application Service Providing" (ASP) erweitert.
Der Name wurde nicht direkt von der indonesischen Insel Java übernommen sondern von einer bei amerikanischen
Programmierern populären Bezeichnung für Kaffee.
III.2 Eigenschaften von JAVA
Die wichtigsten Eigenschaften von Java sind:
•
•
•
•
•
plattformunabhängig
Objekt-orientiert
Syntax ähnlich wie bei C und C++
umfangreiche Klassenbibliothek
Sicherheit von Internet-Anwendungen
Die drei wichtigsten Grundtypen von Java-Programmen sind
•
Konsolenanwendungen
•
GUI-Anwendungen (grafische Anwendungen)
•
Applets
Bei Java-Programmen muss zwischen zwei grundsätzlichen Arten unterschieden werden: Applikationen und Applets.
Applikationen (application)
Java-Applikationen sind Computer-Programme mit dem vollen Funktionsumfang, wie er auch bei anderen
Programmiersprachen gegeben ist. Applikationen können als lokale Programme auf dem Rechner des Benutzers laufen
oder als Client-Server-Systeme über das Internet bzw. über ein Intranet oder als Server-Programme (Servlets, CGIProgramme) auf einem Web-Server.
Technisch gesehen zeichnen sich Java-Applikationen dadurch aus, dass sie eine statische Methode main enthalten.
Applets
Java-Applets werden innerhalb einer Web-Page dargestellt und unter der Kontrolle eines Web-Browsers ausgeführt. Sie
werden meist über das Internet von einem Server geladen, und spezielle Sicherungen innerhalb des Web-Browsers
("Sandkasten", sandbox) sorgen dafür, dass sie keine unerwünschten Wirkungen auf den Client-Rechner haben können.
So können Applets z.B. im Allgemeinen nicht auf lokale Files, Systemkomponenten oder Programme zugreifen und
auch nicht auf Internet-Verbindungen außer zu dem einen Server, von dem sie geladen wurden.
Technisch gesehen zeichnen sich Java-Applets dadurch aus, dass sie Unterklassen der Klasse Applet sind.
Html, JavaScript und Java
- 21 -
15. Februar 2005 / 17:55:51
Die meisten in dieser Kursunterlage beschriebenen Regeln gelten gleichermaßen für Applikationen und Applets. Die
Spezialitäten, die nur für Applets gelten, sind in einem eigenen Kapitel über Applets zusammengefasst.
JavaScript ist nicht Java
JavaScript ist eine Skript-Sprache, die in HTML eingebettet werden kann und bei manchen Web-Browsern (Netscape,
Internet-Explorer) die Ausführung von bestimmten Funktionen und Aktionen innerhalb des Web-Browsers bewirkt.
Im Gegensatz zu Java ist JavaScript
•
•
•
keine selbständige Programmiersprache,
nicht von der Browser-Version unabhängig,
nicht mit den notwendigen Sicherheitsmechanismen ausgestattet.
III.3 Installation SDK
Java Development Kit (JDK)
Das Java Development Kit (JDK) umfasst die für die Erstellung und das Testen von Java-Applikationen und Applets
notwendige Software, die Packages mit den zur Grundausstattung gehörenden Java-Klassen, und die OnlineDokumentation.
Zur Software gehören der Java-Compiler, das Java Runtime Environment (die Java Virtual Machine) für die Ausführung
von Applikationen, der Appletviewer für die Ausführung von Applets, ein Java-Debugger und verschiedene
Hilfsprogramme.
Java ist eine relativ junge Programmiersprache und daher noch immer in Entwicklung, d.h. es kommen immer wieder
neue Versionen mit Ergänzungen und Verbesserungen heraus:
•
•
•
•
•
Die Urversion ist JDK 1.0 (1995).
Im Jahr 1997 kam Version 1.1 heraus, das brachte sowohl Änderungen und neue Konzepte (bei den
Methodennamen gemäß den Beans-Konventionen, beim Event-Handlung, bei den Text-Files) als auch
Erweiterungen durch zusätzliche Packages (z.B. für Datenbanken).
Ende 1998 kam Version 1.2 mit umfangreichen Erweiterungen (unter anderem Swing).
Anfang 2000 folgte Version 1.3 mit Fehlerkorrekturen und Performance-Verbesserungen.
Anfang 2002 brachte die Version 1.4 wieder ein paar größere Erweiterungen.
Seit Version 1.2 wird das JDK auch "Java-Plattform 2" genannt, und das "Java 2 Software Development Kit (SDK)"
bedeutet dann das jeweils aktuelle JDK 1.x, unterteilt in
•
•
•
J2SE = Java 2 Standard Edition (mit Graphischen User Interfaces)
J2EE = Java 2 Enterprise Edition (Server-seitige Erweiterungen zu J2SE)
J2ME = Java 2 Micro Edition (für kleine mobile Geräte)
Die Browser-Unterstützung für Java-Applets hinkt dieser Entwicklung meistens um 1 bis 2 Jahre nach:
•
•
•
Ältere Web-Browser unterstützen (wenn überhaupt) nur Version 1.0.
Die meisten Browser-Versionen unterstützen wenigstens teilweise Version 1.1 (Netscape ab Version 4.06,
Internet Explorer ab Version 4.0).
Mit Hilfe des "Java Activator" (Java Plug-in) von der Firma Sun kann man auch ältere Browser-Versionen auf
die jeweils neueste Java-Version (1.2 etc.) aufrüsten. Bei Netscape ab Version 6.0 und Mozilla und bei Internet
Explorer ab Version 6.0 ist dies der Standardfall.
Wenn Sie Applets für die Verwendung durch einen größeren Benutzerkreis über das Internet erstellen, müssen Sie diese
Einschränkungen berücksichtigen. Der mit dem JDK mitgelieferte Appletviewer unterstützt die jeweilige Version ohne
Einschränkungen.
Das JDK für ein bestimmtes System erhält man meist kostenlos (z.B. zum Download über das Internet) vom jeweiligen
Hersteller, also die Solaris-Version von Sun, die HP-Version von HP, die IBM-Version von IBM. Versionen für
Windows-PC, Macintosh und Linux kann man von Sun oder IBM bekommen.
Environment-Variable
Normalerweise genügt es, das Directory, in dem sich die Java-Software befindet, in die PATH-Variable einzufügen. Die
anderen Variablen (CLASSPATH, JAVA_HOME) werden nur in Spezialfällen oder innerhalb der Software benötigt
Html, JavaScript und Java
- 22 -
15. Februar 2005 / 17:55:51
und müssen normalerweise nicht gesetzt werden. Die folgenden Hinweise sind also in den meisten Fällen nicht
notwendig sondern nur in Spezialfällen:
Die Variable CLASSPATH gibt an, in welchen Directories nach Klassen und Packages gesucht werden soll, getrennt
durch Doppelpunkte (Unix) bzw. Strichpunkte (Windows). im Allgemeinen gibt man hier den Punkt (für das jeweils
aktuelle Directory) und das Start-Directory der im JDK enthaltenen Packages an. Bei neueren JDK-Versionen ist das
jedoch der Standard und der CLASSPATH soll daher gar nicht gesetzt werden.
Die Variable JAVA_HOME gibt an, in welchem Directory die Komponenten des JDK zu finden sind. Die explizite
Angabe ist meistens ebenfalls nicht notwendig.
Damit man den Java-Compiler, das Runtime-System, den Appletviewer etc. einfach aufrufen kann, sollte das
entsprechende bin-Directory in der PATH-Variablen enthalten sein.
Beispiele für die eventuelle Definition dieser Environment-Variablen (die Details hängen von der jeweiligen SoftwareVersion und deren Konfiguration und Installation ab):
MS-Windows, im File autoexec.bat bzw. in der Systemsteuerung:
set PATH=%PATH%;C:\jdk1.1.x\bin
set CLASSPATH=.;C:\jdk1.1.x\lib\classes.zip;
set JAVA_HOME=C:\jdk1.1.x
bzw. ab JDK 1.2:
set PATH=%PATH%;C:\jdk1.x.x\bin
set CLASSPATH=.;C:\jdk1.x.x\jre\lib\rt.jar;
set JAVA_HOME=C:\jdk1.x.x
Filenamen
Jedes Java-Source-File darf nur eine public Klasse enthalten, und der Filename muss dann der Name dieser Klasse (mit
der richtigen Groß-Kleinschreibung) mit der Extension .java sein, hat also die Form
Xxxxx.java
Wenn man das Source-File auf einem PC mit MS-Word, Wordpad oder Notepad erstellt, muss man darauf achten, dass
es mit dem Dateityp Text-File (nicht Word-File) erstellt wird und dass nicht automatisch eine Extension .txt angehängt
wird. Eventuell muss man also beim Speichern den Filenamen mit Quotes in der Form
"Xxxxx.java"
schreiben, damit man nicht einen Filenamen der Form Xxxxx.java.txt erhält.
Der Java-Compiler erzeugt für jede Klasse ein eigenes File, das den Bytecode dieser Klasse enthält. Der Filename ist
dann der Name der Klasse mit der Extension .class, hat also die Form
Xxxxx.class
Man kann auch mehrere Klassen-Files in ein komprimiertes Archiv-File zusammenfassen, das dann weniger
Übertragungszeit über das Internet benötigt. Solche Java-Archiv-Files haben Namen der Form
xxx.jar
JavaCompiler (javac)
Der Aufruf des Java-Compilers erfolgt im einfachsten Fall in der Form
javac Xxxxx.java
Der Name des Source-Files muss mit der Extension .java angegeben werden. Man kann auch mehrere Source-Files
angeben:
javac Xxxxx.java Yyyyy.java
Falls die Klasse andere Klassen verwendet, die neu übersetzt werden müssen, werden diese automatisch ebenfalls
übersetzt, ähnlich wie bei der Unix-Utility make.
Der Compiler erzeugt für jede Klasse ein File Xxxxx.class, das den Bytecode enthält. Dieser Bytecode ist
plattformunabhängig: Egal auf was für einem System der Java-Compiler aufgerufen wurde, der Bytecode kann auch auf
jedem anderen Computersystem ausgeführt werden, zumindest wenn es sich um "100% pure Java" handelt, was bei
manchen Microsoft-Produkten leider nicht garantiert ist.
Html, JavaScript und Java
- 23 -
15. Februar 2005 / 17:55:51
Java Runtime System (java)
Die Ausführung des Bytecodes einer Java-Applikation erfolgt durch Aufruf der Java Virtual Machine JVM (im Java
Runtime Environment JRE) in der Form
java Xxxxx
oder
java Xxxxx parameter parameter
Der Bytecode der Klasse Xxxxx muss im File Xxxxx.class oder in einem Archiv-File (zip, jar) liegen, der Klassenname
muss aber ohne die Extension .class angegeben werden.
Ältere Versionen der JVM waren noch reine Bytecode-Interpreter und daher relativ langsam. Neuere Versionen
erzeugen mit Hilfe von Just-in-Time-Compilation (JIT) und Hotspot-Technologie (Analyse des Laufzeitverhaltens) eine
weitgehende Optimierung und Beschleunigung der Ausführungszeit.
Web-Browser und Appletviewer
Die Darstellung und Ausführung eines Java-Applet erfolgt durch Aufrufen der entsprechenden Web-Page (HTML-File)
mit einem Java-fähigen Web-Browser wie z.B. Netscape, Internet-Explorer oder HotJava.
Für Tests und innerhalb von Java-Schulungen empfiehlt sich die Verwendung des mit dem JDK mitgelieferten
Appletviewer. Dies ist ein einfacher Browser, der alle HTML-Tags außer <applet> und <param> ignoriert und nur das
im HTML-File angeführte Applet ohne den Rest der Web-Page anzeigt. Der Aufruf erfolgt in der Form
appletviewer xxxx.html
oder mit einer kompletten Internet-Adresse (URL):
appletviewer URL
Online-Dokumentation (API)
Die Online-Dokumentation der Klassenbibliothek (application programming interface API) kann zusätzlich zum JDK
am eigenen Rechner installiert oder auf einem Web-Server gespeichert werden. Sie liegt in der Form von Web-Pages
(HTML-Files mit Hypertext-Links) vor und kann mit jedem beliebigen Web-Browser gelesen werden, z.B. mit
Netscape. Man kann den jeweiligen lokalen Filenamen direkt als Aufrufparameter angeben, oder man kann sich zum
File "durchklicken" und es dann in die Bookmarks eintragen und später von dort wiederum aufrufen
Die wichtigsten Files innerhalb dieser Dokumentation sind:
•
•
Class Hierarchy für die Suche nach einer bestimmten Klasse und deren Konstruktoren, Datenfeldern und
Methoden.
All Names (Index of Fields and Methods) für die Suche nach Datenfeldern und Methoden, wenn man nicht
weiß, in welcher Klasse sie definiert sind.
In jedem dieser Files kann man mit dem "Find-in-current" Befehl des Web-Browsers (je nach Browser im Edit-Menü
oder dergleichen) nach Namen oder Substrings suchen. Das Index-File ist sehr groß, es geht daher meistens schneller,
wenn man die Suche im Class-Hierarchy-File beginnt.
Wenn Sie einen Klassennamen anklicken, erhalten Sie die komplette Beschreibung dieser Klasse und ihrer
Konstruktoren, Datenfelder und Methoden sowie eine Angabe ihrer Oberklassen. Falls Sie eine Methode in der
Dokumentation einer Unterklasse nicht finden, dann sehen Sie in ihren Oberklassen nach (siehe Vererbung).
Wenn Sie den Namen einer Methode (oder eines Konstruktors oder Datenfeldes) anklicken, erhalten Sie sofort die
Beschreibung dieser Methode (bzw. des Konstruktors oder Datenfeldes). Dabei müssen Sie aber beachten, dass es
mehrere gleichnamige Methoden und Konstruktoren sowohl innerhalb einer Klasse (siehe Overloading) als auch in
verschiedenen Klassen (siehe Overriding) geben kann.
Java-Archive (jar)
Ein Java-Archiv enthält Dateien und eventuell auch ganze Directory-Strukturen (siehe Packages) in dem selben
komprimierten Format, das auch von PKZIP und Win-Zip verwendet wird. Sie werden mit dem Programm jar (java
archiver) verwaltet, der Aufruf erfolgt ähnlich wie beim Unix-Programm tar (tape archiver):
Archiv-File erstellen (create):
jar -cvf xxx.jar *.class
Html, JavaScript und Java
- 24 -
15. Februar 2005 / 17:55:51
Inhalt eines Archiv-Files anzeigen (table of contents):
jar -tvf xxx.jar
einzelne Dateien aus einem Archiv-File herausholen (extract):
jar -xvf xxx.jar Yyyy.class
Das Herausholen bzw. "Auspacken" von Archiv-Files ist meistens gar nicht nötig: Der Java-Compiler und die Java
Virtual Machine können die Class-Files direkt aus dem Archiv-File lesen und laden. Zu diesem Zweck muss der
Filename des Archiv-Files im Classpath angegeben sein bzw. bei Applets im ARCHIVE-Parameter des Applet-Tag im
HTML-File.
Java Beans
Unter Java Beans ("Kaffeebohnen") versteht man kleine Java-Programme (Klassen) mit genau festgelegten
Konventionen für die Schnittstellen, die eine Wiederverwendung in mehreren Anwendungen (Applikationen und
Applets) ermöglichen, ähnlich wie bei Unterprogramm-Bibliotheken in anderen Programmiersprachen. Dies ist vor
allem im Hinblick auf das Software-Engineering von komplexen Programmsystemen interessant. Dafür gibt es ein
eigenes Beans Development Kit BDK, das man zusätzlich zum JDK installieren kann, und ein Package java.beans, das
ab Version 1.1 im JDK enthalten ist,
Beans werden auch von vielen der oben erwähnten Software-Tools (IDE) unterstützt. Auch die Klassenbibliothek des
JDK ist seit Version 1.2 weitgehend nach den Beans-Konventionen geschrieben, und manche Software-Firmen
verkaufen spezielle Java-Beans für bestimmte Anwendungen.
Es ist empfehlenswert, auch beim Schreiben eigener Java-Programme möglichst die Konventionen von Java-Beans
einzuhalten, also z.B. dass jede Klasse einen Default-Konstruktor mit leerer Parameterliste haben soll, dass die
Methoden für das Setzen und Abfragen von Datenfeldern Namen der Form setXxxxx und getXxxxx bzw. isXxxxx
haben sollen, oder dass alle Klassen so "selbständig" programmiert werden sollen, dass sie unabhängig davon
funktionieren, wie andere Klassen programmiert wurden.
Mehr über diese Grundsätze und Empfehlungen finden Sie im Kapitel über Objekte und Klassen. Für genauere
Informationen über Beans und BeanInfos wird auf die Referenzen verwiesen.
Vorgangsweise
Hier nochmals eine kurze Zusammenfassung der Befehle, die im Normalfall nötig sind, um ein Java-Programm zu
erstellen, zu übersetzen und auszuführen:
Vorgangsweise bei Programmen (Applikationen)
•
•
•
notepad "Xxxxx.java"
javac Xxxxx.java
java Xxxxx
Vorgangsweise bei Applets
•
•
•
•
notepad "Xxxxx.java"
notepad "Xxxxx.html"
javac Xxxxx.java
appletviewer Xxxxx.html
III.4 Erste Gehversuche
Beispiel: Einfache HelloWorld-Applikation
Es ist üblich, einen ersten Eindruck für eine neue Programmiersprache zu geben, indem man ein extrem einfaches
Programm zeigt, das den freundlichen Text "Hello World!" auf die Standard-Ausgabe schreibt.
So sieht dieses Minimal-Programm als Java-Applikation aus:
public class HelloWorld {
public static void main (String[] args) {
}
}
System.out.println("Hello World!");
Html, JavaScript und Java
- 25 -
15. Februar 2005 / 17:55:52
Dieses Java-Source-Programm muss in einem File mit dem Namen HelloWorld.java liegen. Die Übersetzung und
Ausführung erfolgt dann mit
javac HelloWorld.java
java HelloWorld
Ein analoges Beispiel für ein minimales HelloWorld-Applet finden Sie im Kapitel über Applets.
Übung: HelloWorld-Applikation
Schreibe die oben angeführte HelloWorld-Applikation (oder eine Variante davon mit einem anderen Text) in ein JavaSource-File und übersetzen es und führe es aus.
Typische Anfänger-Fehler
Das HelloWorld-Beispiel dient dazu, dass Du die typischen Anfänger-Fehler kennen lernst und in Zukunft vermeiden
kannst. Der erste Fehler war schon: Wenn Du uns nicht den genauen Wortlaut der Fehlermeldung, die Version Deiner
Java-Software (JDK, IDE) und die relevanten Teile Deines Source-Programms dazu sagst, können wir den Fehler nicht
sehen und Dir nicht helfen. In diesem Fall kann ich nur raten. Du hast wahrscheinlich einen der folgenden typischen
Fehler gemacht:
•
•
•
•
•
•
•
•
Du hast das Programm nicht genau genug abgeschrieben (Tippfehler, Groß-Kleinschreibung, Sonderzeichen,
Leerstellen), lies doch die Fehlermeldungen und Korrekturhinweise, die der Compiler Dir gibt.
Du hast das Programm nicht unter dem richtigen Filenamen abgespeichert. Wenn die Klasse HelloWorld heißt,
muss das File HelloWorld.java heißen, nicht helloworld.java und auch nicht HelloWorld.java.txt, im letzteren
Fall versuch es mit
notepad "HelloWorld.java"
Du hast beim Compiler nicht den kompletten Filenamen mit der Extension angegeben (wieder mit der richtigen
Groß-Kleinschreibung):
javac HelloWorld.java
Du hast bei der Ausführung nicht den Klassennamen ohne die Extension angegeben (wieder mit der richtigen
Groß-Kleinschreibung):
java HelloWorld
In der Umgebungsvariable PATH ist das Directory, in dem sich die JDK-Software befindet, nicht neben den
anderen Software-Directories enthalten, versuch
set PATH=%PATH%;C:\jdk1.2\bin
oder wie immer das auf Deinem Rechner heißen muss.
Die Umgebungsvariable CLASSPATH ist (auf einen falschen Wert) gesetzt. Diese Variable sollte überhaupt
nicht gesetzt sein, nur in seltenen Spezialfällen und dann so, dass sie sowohl die Stellen enthält, wo die JavaKlassenbibliotheken liegen, als auch den Punkt für das jeweils aktuelle Directory.
Du hast den Compiler nicht in dem Directory bzw. Folder aufgerufen, in dem Du das Java-File gespeichert
hast.
Du hast ein Applet als Applikation aufgerufen, oder umgekehrt.
Applikationen, die eine main-Methode enthalten, musst Du mit
java Classname
aufrufen.
Applets, die ein "extends Applet" oder "extends JApplet" enthalten, musst Du innerhalb eines geeigneten
HTML-Files mit
appletviewer xxxxx.html
oder mit Netscape oder Internet-Explorer aufrufen.
III.5 JAVA Entwicklungszyklus in Kurzform
Hier noch einmal in Kurzform die Schritte vom Quellcode bis zum lauffähigen Programm:
Html, JavaScript und Java
- 26 -
15. Februar 2005 / 17:55:52
•
•
•
•
•
•
•
•
•
Erstellen Sie die Quelldatei mit einem ASCII-Editor. Verwenden Sie keine Textverarbeitung, denn die
würde dem Code unverständliche Steuerzeichen hinzufügen.
Achten Sie darauf, daß die Datei die Erweiterung .java trägt, und geben Sie ihr exakt denselben Namen
wie der Hauptklasse.
Übersetzen Sie das Programm mit dem Compiler javac, und geben Sie dabei den Dateinamen als
Argument an. Um alle Java-Dateien in einem Verzeichnis zu übersetzen, können Sie auch *.java als
Argument verwenden.
Falls im Quelltext syntaktische Fehler enthalten sind, meldet der Compiler sie zusammen mit der
Zeilennummer und der Quelldatei, in der sie aufgetreten sind. Am Anfang passieren leicht Fehler wie
vergessene oder überflüssige Klammern oder Semikolons. Bedenken Sie auch, daß alle Schlüsselwörter
kleingeschrieben werden und bei Bezeichnern streng zwischen Groß- und Kleinschreibung unterschieden
wird.
Mitunter gibt es Fehlermeldungen, weil Code nicht erreicht werden kann oder Variablen nicht initialisiert
werden. Das ist in Java nicht erlaubt und wird vom Compiler mittels Datenflußanalyse überprüft. Stellen
Sie den Code in einem solchen Fall geeignet um.
Ignorieren Sie zunächst Warnungen, bei denen der Compiler die Verwendung von Klassen oder Methoden,
die als deprecated markiert wurden, kritisiert. Derartige Programmteile funktionieren zwar meist noch,
sind aber veraltet und sollten eigentlich nicht mehr verwendet werden.
Gibt der Compiler gar keine Meldung aus, wurde das Programm erfolgreich übersetzt.
Sie können das Programm nun mit dem Java-Interpreter java starten. Geben Sie als Argument nur den
Klassennamen ohne die Erweiterung .java oder .class an.
Wenn es beim Aufruf des Interpreters eine Fehlermeldung der Art NoClassDefFoundError gibt, liegt
das fast immer daran, daß der Name der Klasse falsch geschrieben wurde oder daß keine oder eine falsch
benannte main-Methode vorhanden ist.
III.6 Tipps und Vereinbarungen
III.6.1 Formatierung der Quelltexte
Es ist bekannt, daß man sich über die Formatierung von Quelltexten und die Einrückung von Deklarationen und
Anweisungen streiten kann. Jeder Entwickler hat seinen eigenen Stil und kennt gute Argumente, genau diesen zu
verwenden. Bei Java-Programmen gibt es einige große Lager, denen man sich anschließen kann. Im professionellen
Umfeld ist man sogar meist gezwungen, sich einem vorgegebenen Stil anzupassen. Wir wollen uns diesen fruchtlosen
Diskussionen nicht anschließen und keinesfalls behaupten, die in diesem Buch verwendete Art der
Quelltextformatierung wäre die einzig richtige. Wir haben jedoch versucht, die Beispielprogramme konsistent zu
formatieren und dabei einige wenige, leicht verständliche Regeln einzuhalten.
Bei Klassen- und Methodendefinitionen stehen die geschweiften Klammern unterhalb der Deklarationsanweisung, und
die eigentliche Deklaration ist eingerückt:
001 import java.io.*;
002
003 public class Listing0204
004 {
005
public static void main(String[] args)
006
{
007
//Hier steht der Methodenrumpf
008
}
009 }
Listing : Einrücken von Klassen und Methoden
Bei Kontrollanweisungen innerhalb einer Methode schreiben wir die öffnende Klammer dagegen in dieselbe Zeile wie
die einleitende Anweisung:
Html, JavaScript und Java
- 27 -
15. Februar 2005 / 17:55:52
001 for (int i = 0; i < aNeighbours.length; ++i) {
002
if (p1.x + aNeighbours[i][0] == p2.x) {
003
if (p1.y + aNeighbours[i][1] == p2.y) {
004
return true;
005
}
006
}
007 }
Listing : Einrücken von Kontrollanweisungen
Dies gilt auch für fortgesetzte Anweisungen wie beispielsweise else oder else if:
001 if (cmd.equals("Größer")) {
002
d.height *= 1.05;
003
d.width *= 1.05;
004 } else if (cmd.equals("Kleiner")) {
005
d.height *= 0.95;
006
d.width *= 0.95;
007 } else {
008
x = 10;
009 }
Listing : Einrücken fortgesetzter Anweisungen
Diese Technik verwenden wir meist auch, wenn bei einem Methodenaufruf nicht alle Argumente in eine Zeile passen:
001 System.out.println(
002
"Grüße aus Hamburg".regionMatches(
003
8,
004
"Greetings from Australia",
005
8,
006
2
007
)
008 );
Listing : Einrücken langer Methodenaufrufe
Diese einfachen Regeln lassen sich in den meisten Fällen anwenden, es gibt aber auch Fälle, in denen sie versagen. So
zum Beispiel, wenn der Testausdruck einer if-Anweisung über mehrere Zeilen geht, wenn die Parameterdeklaration
einer Methode nicht in eine Zeile paßt oder schlicht, wenn die Verschachtelung bereits sehr tief ist und keine weitere
Einrückung zuläßt. In diesem Fall sei der Leser um Nachsicht gebeten und aufgefordert, den ästhetischen Anspruch an
das Programm den jeweiligen pragmatischen Erwägungen unterzuordnen.
III.6.2 Namenskonventionen
Wie in allen Programmiersprachen, gibt es auch in Java Konventionen für die Vergabe von Namen. Sie sind zwar nicht
zwingend erforderlich, erleichtern aber das Verständnis der Quelltexte ungemein und sollten daher unbedingt
eingehalten werden. Die wichtigsten sind:
•
•
•
•
Klassennamen beginnen stets mit einem Großbuchstaben. Beispiele sind String, Vector oder Hello.
Besteht ein Klassenname aus mehreren Silben, können zur Steigerung der Übersichtlichkeit auch die
Folgesilben mit einem Großbuchstaben beginnen. Beispiele dafür wären HelloWorld, KeyAdapter oder
NoSuchMethodException. Klassennamen, die nur aus Großbuchstaben bestehen, sind unüblich.
Methodennamen beginnen mit einem Kleinbuchstaben. Haben sie mehrere Silben, ist die erste oft ein Verb.
Weitere beginnen mit einem Großbuchstaben. Beispiele sind println, hasMoreElements oder
isEnabled.
Paketnamen bestehen ausschließlich aus Kleinbuchstaben. Beispiele sind java.lang,
javax.swing.event oder com.solution42.util (mehrteilige Paketnamen werden durch Punkte
separiert).
Für Variablennamen gelten dieselben Konventionen wie für Methoden. Es ist unüblich, Membervariablen mit
einem Präfix wie z.B. "m_" zu versehen. Auch die Verwendung der ungarischen Notation, bei der Variablen
datentypbezogene Namenspräfixe erhalten, ist in Java nicht üblich.
Weitere Konventionen werden, wenn erforderlich, im Buch beschrieben.
III.6.3 Aufruf von Java-Programmen unter Windows
Immer wieder wird gefragt, wie man Java-Programme möglichst einfach unter Windows aufrufen kann. Das Starten aus
Html, JavaScript und Java
- 28 -
15. Februar 2005 / 17:55:52
der DOS-Box erscheint vielen Lesern zu umständlich, und bei einem Java-Programm mit grafischer Oberfläche stört das
überflüssige Konsolenfenster. Im Gegensatz zu com- oder exe-Dateien ist ein kompiliertes Java-Programm zwar nicht
direkt ausführbar, aber es gibt doch einige Möglichkeiten, das Starten unter Windows zu vereinfachen.
III.6.4 Erstellen einer Batchdatei
Eine erste Vereinfachung besteht darin, eine Batchdatei zu erstellen, aus der der java-Interpreter mit dem JavaProgramm als Argument aufgerufen wird. Soll beispielsweise das Java-Programm Listing3701, dessen Bytecode
Listing3701.class im Verzeichnis c:\tmp liegt, mit dem java-Interpreter, der in das Verzeichnis c:\jdk1.4 installiert
wurde, gestartet werden, kann dazu folgende Batch-Datei verwendet werden:
@echo off
c:
cd \tmp
c:\jdk1.4\bin\java Listing3701
Wird diese beispielsweise go3701.bat genannt und in ein Verzeichnis gelegt, das über die PATH-Angabe zu erreichen
ist, kann unser Java-Programm durch einfache Eingabe des Kommandos go3701 aus jedem Verzeichnis heraus oder
aus dem »Ausführen«-Dialog des Startmenüs gestartet werden.
III.6.5 Erstellen einer Verknüpfung auf dem Desktop
Ebenso leicht ist es möglich, ein Java-Programm durch einen Doppelklick auf ein Desktop-Symbol zu starten. Dazu
wird eine Verknüpfung angelegt, die den java-Interpreter mit dem Programmnamen als Argument aufruft. Nach einem
rechten Mausklick auf den Windows-Desktop ist dazu zunächst der Menüpunkt »Neu.Verknüpfung« aufzurufen.
Anschließend sind die Angaben für Programm, Arbeitsverzeichnis und Icon so zu machen, daß der spätere
Eigenschaften-Dialog des neu angelegten Symbols wie folgt aussieht (beispielhaft für Windows 98):
Abbildung : Eine Verknüpfung auf dem Windows-Desktop
Das Java-Programm kann nun wie jedes andere Windows-Programm per Doppelklick vom Desktop aus gestartet
werden.
III.6.6 Verwenden von javaw anstelle von java
Soll ein java-Programm, das eine grafische Oberfläche hat, ohne Konsolenfenster gestartet werden, kann anstelle des
Standard-Interpreters java der alternative Interpreter javaw verwendet werden. Er arbeitet genauso wie java und
akzeptiert dieselben Optionen (siehe Abschnitt 50.2), stellt der Anwendung aber kein Konsolenfenster zur Verfügung.
Zu beachten ist allerdings, daß alle Ausgaben auf System.out und System.err ins Leere gehen.
III.6.7 Troubleshooting
Nachfolgend noch einmal eine kurze Zusammenfassung der häufigsten Probleme beim Erstellen, Übersetzen und Starten
eines Java-Programms, inklusive Beschreibung, wie man sie behebt oder umgeht.
III.6.7.1 Was ist eine DOS-Box und wie startet man sie?
Alle Werkzeuge des JDK arbeiten kommandozeilenorientiert. Anders als typische GUI-Programme wie Adobe
Html, JavaScript und Java
- 29 -
15. Februar 2005 / 17:55:52
Photoshop, Microsoft Excel oder Netscape Navigator besitzen sie also keine grafische Oberfläche, sondern werden aus
einer »DOS-Box« (bzw. einer UNIX-Shell) heraus aufgerufen. Diese wird unter Windows-Betriebsystemen als »MSDOS-Eingabeaufforderung« bezeichnet und ist meist im Startmenü (unter »Programme«) zu finden. In der DOS-Box
werden Befehle und ihre Parameter über die Tastatur eingegeben und starten so die zugehörigen Programme. Um in
einer DOS-Box zurecht zu kommen, sollte man deren Kommandosyntax und die wichtigsten Befehle zum Starten von
Programmen und für Datei- und Verzeichnisoperationen kennen. Beides wird in unzähligen Büchern und (zum Teil) in
den Hilfedateien des Betriebssystems beschrieben.
Das UNIX-Pendant zu einer DOS-Box ist die Shell. Auch sie dient primär dazu, Benutzerkommandos zu empfangen
und auszuführen. UNIX-Shells sind wesentlich mächtiger als DOS-Boxen unter Windows, und im Laufe der Jahre haben
sich verschiedene Varianten entwickelt (Bourne-Shell, C-Shell, Korn-Shell, BASH etc.). Obwohl viele der elementaren
Shell-Kommandos den DOS-Box-Pendants gleichen oder ihnen recht ähnlich sind, lassen sich mit ihrer detaillierten
Beschreibung leicht ganze Bücher füllen. Das Kommando man liefert eine Beschreibung der Shell und aller
zugehörigen UNIX-Kommandos.
Wer nicht kommandozeilenorientiert arbeiten will, kann statt der im Buch beschriebenen JDK-Werkzeuge natürlich
auch eine integrierte Entwicklungsumgebung zum Erlernen der Java-Programmierung verwenden (z.B. Borland
JBuilder). In diesem Fall stehen Editor, Compiler, Interpreter und alle anderen Werkzeuge unter einer gemeinsamen und
einheitlichen grafischen Oberfläche zur Verfügung und können auf Knopfdruck gestartet werden. Der Nachteil dieser
integrierten Werkzeuge ist allerdings eine etwas höhere Einarbeitungszeit, denn von der Vielzahl der Möglichkeiten
wird man zunächst erschlagen. Zudem sind wichtige Techniken und Arbeitsschritte oftmals hinter Hilfsprogrammen und
Assistenten verborgen und erschweren so das Verständnis grundlegender Konzepte.
III.6.7.2 java läuft, javac aber nicht
Wenn unter Windows der Java-Interpreter java gestartet werden kann, beim Aufruf des Compilers javac aber eine
Fehlermeldung kommt, liegt das meist daran, daß der PATH nicht korrekt gesetzt wurde. Während die JDK-Installation
den Interpreter unter anderem auch in Verzeichnisse kopiert, auf die der PATH bereits verweist (so daß dieser ohne
weiteres Zutun aus jedem Verzeichnis aufgerufen werden kann), ist das für den Compiler und die übrigen JDKWerkzeuge nicht der Fall. Diese können nur dann ohne vorangestellten Pfad aufgerufen werden, wenn der PATH auf das
Unterverzeichnis bin des Installationsverzeichnisses verweist. Bei der in diesem Buch angenommen StandardInstallation muß die PATH-Variable also das Verzeichnis c:\jdk1.4\bin enthalten.
III.6.7.3 Was sind eigentlich Umgebungsvariablen?
Einer der Standardmechanismen zur Konfiguration von Programmen besteht darin, Umgebungsvariablen zu setzen.
Diese werden vom Anwender (meist innerhalb einer DOS-Box bzw. Shell mit Hilfe des set-Kommandos) gesetzt und
vom Programm gelesen und zur Konfiguration verwendet. Die beiden für das JDK wichtigsten Umgebungsvariablen
sind PATH und CLASSPATH. Über erstere wird dem Betriebssystem mitgeteilt, wo es nach ausführbaren Programmen
suchen soll, also etwa nach dem Compiler oder Interpreter des JDK. Die Umgebungsvariable CLASSPATH
(umgangssprachlich »der CLASSPATH« genannt) ist JDK-spezifisch. Sie zeigt dem Compiler und Interpreter an, in
welchen Verzeichnissen er nach Klassendateien suchen soll. Im Gegensatz zu PATH kann der CLASSPATH bei der
Standardinstallation eines aktuellen JDKs (Version 1.3 oder später) ungesetzt bleiben. Compiler und Interpreter finden
ihr eigenes Laufzeitsystem automatisch, und die selbst geschriebenen Klassen werden im aktuellen Verzeichnis gesucht.
Da es zu umständlich ist, häufig benötigte Umgebungsvariablen nach jedem Aufruf einer DOS-Box neu zu setzen,
bieten alle Betriebssysteme die Möglichkeit, sie permanent festzulegen. Abschnitt 2.1.2 erläutert dies am Beispiel der
PATH-Variable.
III.6.7.4 Der Compiler javac arbeitet nicht
Wenn der Compiler javac die .java-Datei nicht findet, liegt dies in aller Regel daran, daß sie nicht existiert. Der
Compiler unterscheidet zwischen Groß- und Kleinschreibung; die Datei Test1.java ist somit streng von test1.java oder
TEST1.JAVA zu unterscheiden. Zudem muß die Dateierweiterung .java lauten, denn andere Erweiterungen werden
nicht akzeptiert. Hat der Editor fälschlicherweise die Erweiterung .txt angehängt, wird die Datei vom Compiler nicht
gefunden. Mitunter kommt es auch vor, daß Beispieldateien beim Kopieren oder Entpacken in das MS-DOS-8.3-Format
konvertiert werden. Die Datei Test1.java würde dann TEST1.JAV heißen und vom Compiler nicht akzeptiert werden.
Wichtig ist auch, daß der Compiler korrekt aufgerufen wird. Anders als beim Interpreter wird die Dateierweiterung stets
angegeben. Ein Aufruf von javac Test1 wird also nicht funktionieren, javac Test1.java dagegen sehr wohl.
Schließlich ist zu beachten, daß die zu übersetzende Klasse denselben Basisnamen hat wie die Datei, in der sie definiert
wurde. In der Datei Test1.java muß also eine öffentliche Klasse mit dem Namen Test1 definiert worden sein.
Html, JavaScript und Java
- 30 -
15. Februar 2005 / 17:55:53
III.6.7.5 Der Interpreter java arbeitet nicht korrekt
Der häufigste Fehler beim Aufruf des Interpreters ist ein »NoClassDefFoundError«. Ein trivialer Fehler besteht darin,
daß der Interpreter falsch aufgerufen wurde. Im Gegensatz zum Compiler möchte er keinen Dateinamen als Argument
übergeben bekommen, sondern einen Klassennamen. Folglich darf die Erweiterung .java oder .class nicht angegeben
werden. Die in die Datei Test1.class übersetzte Klasse Test1 wird also durch Aufruf von java Test1 gestartet, und
nicht durch java Test1.class.
Das funktioniert allerdings nur, und das ist auch schon die zweite Fehlerquelle, wenn Test1 auch tatsächlich eine
Methode public static void main enthält. Diese versucht nämlich der Interpreter zu starten, und wenn sie
nicht vorhanden ist, gibt es obige Fehlermeldung.
Ist der Aufruf korrekt und die main-Methode ebenso vorhanden wie die nötige Klassendatei, kann es trotzdem
vorkommen, daß der Interpreter die Klasse nicht starten kann. Das liegt dann meist daran, daß etwas mit dem
CLASSPATH nicht stimmt. Der CLASSPATH ist eine Umgebungsvariable, die eine Liste von Verzeichnissen und
Archivdateien enthält, die vom Interpreter der Reihe nach durchsucht werden, um die auszuführenden Klassen zu finden.
Die genaue Interpretation des CLASSPATH hat sich über die Jahre etwas geändert, aber bei aktuellen JDK-Versionen
kann sie wie folgt zusammengefaßt werden:
Ist gar kein CLASSPATH angegeben, sucht der Interpreter im aktuellen Verzeichnis (bzw. bei Klassen in Unterpaketen
in darin befindlichen Unterverzeichnissen) nach der Klassendatei. Ist dagegen eine Umgebungsvariable CLASSPATH
vorhanden, durchsucht der Interpreter dessen Elemente der Reihe nach. Befindet sich darin nicht das aktuelle
Verzeichnis (entweder absolut oder als ».« angegeben), so werden auch keine Klassen gefunden, die im aktuellen
Verzeichnis liegen. Für unsere ersten Versuche ist es bei aktuellen JDKs also am besten, den CLASSPATH gar nicht zu
setzen und alle Klassen in das aktuelle Verzeichnis zu legen.
Mitunter wird der CLASSPATH von anderen installierten Java-Programmen verändert und sorgt so unbeabsichtigt dafür,
daß die eigenen Klassen nicht mehr gefunden werden. Das ist zwar kein guter Stil, kommt in der Praxis aber dennoch
manchmal vor. In einem solchen Fall muß der CLASSPATH während der eigenen Experimente zurückgesetzt oder so
geändert werden, daß das aktuelle Verzeichnis (bzw. das mit den eigenen Klassendateien) darin enthalten ist.
III.6.7.6 Zusätzlich benötigte Klassen werden nicht gefunden
Gibt es beim Ausführen eines Beispielprogramms die Fehlermeldung, daß eine andere als die aufgerufene Klasse nicht
gefunden werden kann, liegt das meist daran, daß deren .class-Datei nicht mit aus dem Verzeichnis mit den
Beispieldateien in das aktuelle Verzeichnis kopiert wurde. Prominentester Kandidat ist der
WindowClosingAdapter, der von fast allen Beispielprogrammen benötigt wird, die eine grafische Oberfläche
haben.
Html, JavaScript und Java
- 31 -
15. Februar 2005 / 17:55:53
III.7 Konsolenanwendungen
III.7.1 Grundstruktur eines JAVA-Programms
•
Ein Programm ist ein allgemeiner Begriff, der eine Menge von einer oder mehrerer Java-Klassen
beschreibt, die übersetzt und ausgeführt werden können
•
Eine Klasse beschreibt die Variablen und Methoden, die zu einem bestimmten realen Gegenstand passen
•
Ein Objekt wird durch eine new-Anweisung aus einer Klasse erzeugt. Das Erzeugen eines Objekts wird
auch als Instanzierung bezeichnet.
•
Eine Variable enthält einen Wert, auf dem eine Methode arbeiten kann.
•
Ein Bezeichner ist der Name einer Entität in Java
•
Anweisung: Die Arbeit eines Programms wird durch seine Anweisungen verrichtet. Eine Anweisung löst
eine bestimmte Aktion aus.
•
Konstruktor: Jede Klasse verfügt über eine spezielle Methode, die man Konstruktor nennt. Der Konstruktor
hat dieselbe Bezeichnung wie die Klasse.
•
Parameter: Einen Methodenaufruf kann man variieren, indem man Parameterwerte in Klammern hinzufügt.
•
Jede Codezeile wird mit einem Semikolon (;) abgeschlossen, außer bei der Definition von Klassen.
•
Zusammengehörige, mehrere Befehle werden, wie in C, mit geschweiften Klammern ( {} ) eingeschlossen.
•
Rückgabewerte: Methoden, die einen Rückgabewert zurück liefern möchten, müssen den Datentyp des
Rückgabewertes in der Methodendefinition vor dem Methodennamen angeben:
public int methode(int a, int b)
Diese Methode erwartet beispielsweise zwei int-Argumente und liefert einen int-Wert als Ergebnis zurück.
Zum Zurückliefern des Ergebnisses wird die return-Anweisung verwendet. Hinter das Schlüsselwort return
in einer neuen Zeile wird einfach der zurückzuliefernde Wert (Variable oder Ausdruck) geschrieben.
Public int machwas(int a, int b) {
return a*b
}
•
Void: Methoden, die keinen Rückgabewert zurückliefern, müssen in der Definition als Datentyp void
angegeben werden
•
Public: Zugriffe und Zugriffsbeschränkungen werden immer aus der Sicht der Klasse festgelegt. Man
unterscheidet
Html, JavaScript und Java
- 32 -
15. Februar 2005 / 17:55:53
•
den Zugriff von innen. (Ein Element der Klasse greift auf ein anderes Element der Klasse zu )
•
den Zugriff von außen. (aus einer anderen Klasse heraus)
Während der Zugriff von innen keinerlei Zugriffsbeschränkung unterliegt und grundsätzlich über den
Namen des Elements erfolgt, unterliegt der Zugriff von außen der Regelung durch den Zugriffsspezifizierer
und erfolgt meist über qualifizierte Bezeichner, also mit dem Punktoperator.
Bspl.:
Java.util.Math.PI
•
main(): Die main()-Methode muss immer mit dem Schlüsselwort public deklariert werden, damit sie von
der Java Virtual Machine aufgerufen und ausgeführt werden kann. Main() ist die Eintrittsmethode, mit der
die Programmausführung beginnt. Jedes Programm muss genau eine main()-Methode enthalten und diese
muss als static deklariert sein, damit sie von der Java Virtual Machine ohne Instanzierung ausgeführt
werden kann.
•
Der Ausdruck String args[ ] oder String[ ] args definiert ein Feld von Zeichenketten, das die Parameter der
Kommandozeile aufnimmt.
•
Klammern { } dienen zur Bildung eines Blocks von Anweisungen
•
Anhand des Semikolons erkennt der Compiler das Befehlsende.
•
Der auszugebende Text steht in doppelten Anführungszeichen. Innerhalb des Textes kann man ESCAPESequenzen zur Textsteuereung einfügen:
\b
backspace
\t
Horizontal tab
\n
Line feed
\f
Form feed
\r
Carriage return
\“
Anführungszeichen
\´
Hochkomma
\ß
Backslash \
III.7.2 Imperative und objektorientierte Programmiersprachen
Am Beispiel eines kleinen Programms soll der Unterschied in der Programmierungstechnik bei herkömmlichen,
imperativen Programmiersprachen, wie Basic, Pascal, Fortran, usw. gegenüber einer konsequent objektorientierten
Programmiersprache, wie Delphi, Java herausgearbeitet werden.
Aufgabe: Gesucht sind die Lösungen einer quadratischen Gleichung der Form ax²+bx+c=0.
Imperatives Programmieren:
Um die Aufgabe zu lösen, zerlegt man das gegebene Problem nach dem E-V-A-Prinzip (E-Eingabe-V-Verarbeitung und
A-Ausgabe) in 3 Hauptblöcke. Eine weitere Unterteilung zerlegt jeden Block noch einmal in weitere feinere Schritte, die
nacheinander abgearbeitet werden können. Am Ende wird das Programm dann zeilenweise abgearbeitet. Zur Darstellung
dieser zeilenweise orientierten Programiertechnik werden, je nach Programmiersprache, entweder Flussdiagramme oder
Struktogramme verwendet.
Stellt man ein Flussdiagramm des Programms auf, so sieht man deutlich die statische, lineare Programmiertechnik:
Html, JavaScript und Java
- 33 -
15. Februar 2005 / 17:55:53
Flussdiagramm
Struktogramm
Objektorientiertes Programmieren:
Beim objekorientiertem Programmieren verwendet man die von Booch, Jacobson und Rumbaugh entwickelte sog. UML
(=Unified Modeling Language), um Beziehungen zwischen Klassen darzustellen. Rechtecke mit evtl. weiteren
Unterteilungen für Methoden tragen die Namen der Klassen. Pfeile repräsentieren die Beziehungen zwischen ihnen.
Dabei gliedert sich die moderne Software-Entwicklung grundsätzlich in 5 Phasen:
1.Anforderungsspezifikation - Hier wird festgelegt, welchem Zweck das Programm dienen soll und welche
Aufgaben es erfüllen soll.
2.Analyse - In dieser Phase werden Bedienung und Arbeitsweise des Programms ausgearbeitet.
3.Design - Hier werden die Ergebnisse der Analyse ausgewertet und in Klassenspezifikationen umgesetzt. Dabei
ist zu erfassen, welche Klassen (Objekte) benötigt werden, welches die wichtigsten Elemente der Klassen sind
und in welchen Beziehungen die Klassen zueinander stehen.
4.Implementation - Das Klassen-Design wird in Code umgesetzt
5.Test - Das Programm wird kompiliert und auf syntaktische und Laufzeitfehler getestet.
Analyse eines kleinen Beispiels ist zu finden in Dirk Louis Peter Müller „Java 2“ S. 320 ff.
Gute UML-basierte CASE-Tools sind:
Rational Rose (http://www.rational.com)
ObjectiF (http://www.microtool.de)
ArgoUML (http://argouml.tigris.org)
III.8 Objektorientierte Programmierung
Bei der objektorientierten Programmierung geht man nicht von sequentiell angeordneten Zeilen aus, die nacheinander
ausgeführt werden, sondern von sog. Objekten. Einem Objekt zugeordnet werden Eigenschaften und Methoden. Ein so
definierter Objekttyp wird auch Klasse genannt. Bspl.: Alle Buttons sind Objekte, die von der Klasse Tbutton abgeleitet
sind. Beim Programmieren schafft man sich nun „Kopien“, sog. Instanzen, von den so definierten Klassen und weist
ihnen spezifische Eigenschaften und Methoden zu. Ein Objekt ist also immer eine Instanz einer Klasse. Bspl.: Hans ist
eine Instanz der Klasse Mensch, der Golf ist eine Instanz der Klasse Auto.
Ein weiteres charaketristisches Merkmal der objektorientierten Programmierung sind Kapselung und Vererbung. Die
Html, JavaScript und Java
- 34 -
15. Februar 2005 / 17:55:53
Idee bei der Kapselung besteht darin, alle Objekteigenschaften und zugehörigen Methoden in einer Klasse zu vereinen.
Klassen und Unterklassen sind hierarchisch strukturiert und abgeleitete Klassen übernehmen die Eigenschaften und
Methoden aller übergeordneten Klassen. (=Vererbung)
Um eine Klasse innerhalb eines Java-Programms nutzen zu können, muss diese zuerst importiert werden. Dies geschieht
mit der Anweisung
import paketname.*;
Das Zeichen * ist eine sog. Wildcard und steht für alle Klassen dieses Pakets. Das Paket java.lang muss nicht explizit
importiert werden. Es enthält alle Basisspracheigenschaften von Java und wird vom Compiler automatisch geladen.
III.8.1 Pakete und Klassen von Java
Die Klassen von Java sind in verschiedene Pakete aufgeteilt. Die wichtigsten Pakete sind:
•
java.applet: Paket, das Klassen für Java-Applets bereitstellt
•
java.awt: Paket, das Klassen für die grafischen Oberflächen bereitstellt und weitere Unterpakete enthält, wie
z.B. java.awt.event, java.awt.print
•
java.io: Paket, das Klassen für die Ein- und Ausgabe von dateien enthält
•
java.lang: Basispaket von Java.applet
•
java.net: Paket, das Klassen für Netzwerkverbindungen enthält
•
java.util: Paket, das Klassen für häufig gebrauchte Anwendungen, z.B. Datum, Uhrzeit, bereitstellt
Die oberste aller Klassen ist die Klasse Object. Zusätzlich gibt es noch erweiterte Pakete, die mit javax gekennzeichnet
werden, z.B. javax.swing usw.
Html, JavaScript und Java
- 35 -
15. Februar 2005 / 17:55:53
Bspl: Lösung einer quadratischen Gleichung
public class PQFormel3
{
public static void main(String[] args)
{
double a,b,c,d,x1,x2;
int s;
a=1.;
b=1.;
c=1.;
//Diskriminante
d=b*b-4*a*c;
s=0;
if (d!=0) {s=(int) (d/Math.abs(d));}
switch (s)
{case 0: { // eine Lösungen
x1=(-b+Math.sqrt(d))/(2*a);
System.out.println("Nur eine Lösung"+x1);
break; }
//case 0
case 1:
{ // zwei Lösungen
x1=(-b+Math.sqrt(d))/(2*a);
System.out.println("Erste Lösung"+x1);
x2=(-b-Math.sqrt(d))/(2*a);
System.out.println("Zweite Lösung"+x2);
break;
}
// case 1
case -1:
{ System.out.println("Keine Lösung"); } // case -1
}
// switch
} // main
} //public class
III.8.2 JAVA Sprachelemente
III.8.2.1 Schlüsselwörter
Tabelle 1: Schlüsselwörter unter Java
abstract
else
int
static
boolean
extends
interface
super
break
false
long
switch
byte
final
native
synchronized
byvalue
finally
new
this
case
float
null
throw
cast
for
operator
throws
catch
future
outer
transient
char
generic
package
true
class
goto
private
try
const
if
protected
var
continue
implements
public
void
default
import
rest
volatile
do
inner
return
while
double
instanceof
short
III.8.2.2 Datentypen
Übersicht über elementare Basisdatentypen in Java:
Html, JavaScript und Java
- 36 -
15. Februar 2005 / 17:55:54
Hinzu kommen noch Strings, Felder und andere vordefinierte Datentypen:
III.8.2.3 Variablen
Eine Variable ist ein Name für einen Speicherbereich, in dem Daten abgelegt werden können.
Deklaration:
typ variablenname;
Mit Hilfe des Komma-Operators können mehrere Variablen des gleichen Datentyps hintereinander definiert werden.
Bspl.:
•
int i;
•
int i,j,n;
•
double bruch;
•
String name;
Initialisierung: Variablen können bereits bei der Deklaration einen Wert zugewiesen bekommen:
•
int alter=24;
•
int i=0, j=1, n=2;
Konstanten: (finale Variablen) Mit dem Schlüsselwort verwandelt man Variablen in konstante Variablen, d.h. Ihnen
kann nur einmal ein Wert zugewiesen werden. Z.B.
•
Html, JavaScript und Java
final double Pi=3.14159;
- 37 -
15. Februar 2005 / 17:55:54
Elementare Datentypen:
Type
Speicherung
Wertebereich
byte
8 Bit
-128 bis 127
short
16 Bit
-32768 bis 32767
int
32 Bit
- 231 bis 231 - 1
long
64 Bit
- 263 bis 263 - 1
Typ
Speicherung
Wertebereich
float
32 Bit
-3,40282347 1038 bis 3,40282347 1038
double
64 Bit
- 1,797693138462315750 10308 bis 1,797693138462315750 10308
Ein String ist ein Objekt, bestehend aus mehreren Zeichen. Daher muss er instanziert werden, also erzeugt werden mit
dem Befehl new. Strings entstehen also , im Gegensatz zu Variablen, durch Instanziierung von Objekten.
Bspl.: Statt String nachname = new String(„Popp“); kann man auch schreiben String nachname = „Popp“;
III.8.2.4 Verzweigungen (If/else, Switch, Case)
Bei unserer Beispielaufgabe mit den Lösungen einer quadratischen Gleichung taucht das Problem auf, eine
Fallunterscheidung zu verschachteln. Je nachdem, ob die Diskriminante (D) Null, größer Null oder kleiner Null ist, gibt
es ja eine, zwei oder keine reelle Lösung. Die erste Möglichkeit dieses Problem zu lösen besteht in einer
Verschachtelung von IF-Abfragen :
if (D<0) { Meldung = „Keine reelle Lösung“;)}
else {if (D=0) {Meldung = „Eine relle Lösung“;}
else Meldung =“Zwei reelle Lösungen“;}
}
Schöner wäre es, hätte man eine Dreiteilung zur Verfügung. Bei der Realisierung dieses Falls muss eine Variable vom
Typ integer zur Verzweigung verwendet werden. Im Beispiel ist dies die Variable S vom Typ integer, die je nach
Vorzeichen der Diskriminante den Wert -1, 0 oder +1 annimmt. Das erreicht man dadurch, dass man den Wert von D
durch seinen Betrag dividiert. Das liefert entweder +1 oder -1, solange D nicht 0 ist. Anschließend muss man das
Ergebnis noch zu einem integer-Wert konvertieren mit (int) und die Null noch abgefragt werden (if d!=0). Somit erhält
man folgenden Quellcode:
//Diskriminante
d=b*b-4*a*c;
s=0;
if (d!=0) {s=(int) (d/Math.abs(d));}
switch (s)
{case 0: { // eine Lösungen
x1=(-b+Math.sqrt(d))/(2*a);
System.out.println(„Nur eine Lösung“+x1);
break; } //case 0
case 1: { // zwei Lösungen
x1=(-b+Math.sqrt(d))/(2*a);
System.out.println(„Erste Lösung“+x1);
x2=(-b-Math.sqrt(d))/(2*a);
System.out.println(„Zweite Lösung“+x2);
break; } // case 1
case -1:
{ System.out.println(„Keine Lösung“); // case -1
} // switch
Im Gegensatz zu anderen Programmiersprachen geht Java nach dem Sprung nicht an das Ende von switch, sondern
arbeitet die nächste Anweisung ab. Um dies zu verhindern, muss in jeder Unterabteilung ein break eingebaut werden!
Html, JavaScript und Java
- 38 -
15. Februar 2005 / 17:55:54
Das folgende Beispiel zeigt eine Variante der if-else-Anweisung. Hierbei wird mit einer Folge von else if eine Kette von
Abfragen aufgebaut
int z=4;
if (z== 1)
{
System.out.println("Z=1");
}
else if (z==2)
{
System.out.println("Z=2");
}
else if (z==3)
{
System.out.println("Z=3");
}
else
{
System.out.println("Z ist <1 oder >3");
}
Sollen Mehrfachentscheidungen getroffen werden, so kann die switch-Anweisung mittels eines IntegerAusdrucks verwendet werden.
Beispiel :
switch (<Ausdruck>) {
case <konstanterAusdruck>:
<Anweisung> [<Anweisung> ...]
case <konstanterAusdruck>:
<Anweisung> [<Anweisung> ...]
...
default:
<Anweisung> [<Anweisung> ...] }
III.8.2.5 Die FOR-Schleife
Eine Eigenschaft der for-Schleife ist, dass man bereits zu Beginn der Schleife wissen muss, wie oft sie
durchlaufen werden soll.
Die formale Syntax der for-Schleife lautet:
for (startwert; [<logischerAusdruck>]; schleifenwert)
<Anweisung>
Beispiel:
int i;
for (i = 1; i <= 10; i++)
{
System.out.print(i + " ");
}
System.out.println("\n" + i );
III.8.2.6 While und Do...while Schleife
Beispiel: Umrechnungstabelle von Altgrad in Bogenmaß
final static float pi=3.14159f;
float x;
int i=0;
while (i <= 360)
{
x = pi* i / 180;
System.out.println(i + " : " + x);
Beispiel einer do-Schleife
final static float pi=3.14159f;
float x;
Html, JavaScript und Java
- 39 -
15. Februar 2005 / 17:55:54
int i=0;
do {
x = pi* i / 180;
System.out.println(i + " : " + x);
i++;
} while (i <= 360);
III.8.3 I/O-Erweiterung
Leider ist es etwas komplizierter, Daten zeichenweise von der Tastatur zu lesen. Zwar steht ein vordefinierter EingabeStream System.in zur Verfügung. Er ist aber nicht in der Lage, die eingelesenen Zeichen in primitive Datentypen zu
konvertieren. Statt dessen muß zunächst eine Instanz der Klasse InputStreamReader und daraus ein
BufferedReader erzeugt werden. Dieser kann dann dazu verwendet werden, die Eingabe zeilenweise zu lesen und
das Ergebnis in einen primitiven Typ umzuwandeln.
Das folgende Listing zeigt ein Programm, das zwei Ganzzahlen einliest, sie zusammenzählt und das Ergebnis auf dem
Bildschirm ausgibt:
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
/* Listing0203.java */
Listing0203.java
import java.io.*;
public class Listing0203
{
public static void main(String[] args)
throws IOException
{
int a, b, c;
BufferedReader din = new BufferedReader(
new InputStreamReader(System.in));
}
}
System.out.println("Bitte a eingeben: ");
a = Integer.parseInt(din.readLine());
System.out.println("Bitte b eingeben: ");
b = Integer.parseInt(din.readLine());
c = a + b;
System.out.println("a+b="+c);
Quellcodeanalyse:
Die import-Anweisung am Anfang des Listings dient dazu, die Klassen des Pakets java.io bekanntzumachen.
Ohne diese Anweisung würden sowohl BufferedReader als auch InputStreamReader vom Compiler nicht
gefunden und es gäbe eine entsprechende Fehlermeldung. Auch in nachfolgenden Beispielprogrammen tauchen von Zeit
zu Zeit import-Anweisungen auf, die java.lang oder andere Pakete einbinden. In Kapitel 13 werden wir
ausführlich auf die Verwendung und das Erstellen von Paketen eingehen.
Werden die Zahlen 10 und 20 eingegeben, so lautet die Ausgabe des Programms:
Bitte a eingeben:
10
Bitte b eingeben:
20
a+b=30
Html, JavaScript und Java
- 40 -
15. Februar 2005 / 17:55:54
III.9 Grafische Oberflächen / GUI Programmierung
Aufgabe eines GUI-Programms (Graphical User Interface) ist es, eine grafische Benutzeroberfläche aufzubauen und die
vom Windowing-System verschickten Nachrichten abzufangen und auszuwerten. Zur Erfüllung dieser Aufgabe stellt das
Windowing-System eine sogenannte API ( Application Programming Interface) zur Einrichtung von Fenstern,
Steuerelementen usw. zur Verfügung. Ein Java-Programm kann mit diesen APIs wenig anfangen, da diese schon älter,
nicht objektorientiert und hardwarenah sind. Statt dessen stellt Java zwei Klassenbibliotheken, Java-AWT und JavaSwing, zur Erstellung von GUI-Anwendungen zur Verfügung. Die Klassenbibliothek SWING ergänzt und ersetzt zum
Teil die AWT-Bibliothek. Heute sollte man die SWING-Klassen verwenden. Diese lauten meist so wie ihr AWTPendant, allerdings mit vorangestelltem „J“ ( z.B. Jbutton statt Button ).
III.9.1 AWT und SWING
Das Abstract Window Toolkit (AWT) ist der Bestandteil des Java Development Kit, mit dem sich grafische
Benutzeroberflächen erstellen lassen. Hier ein Überblick über die wichtigsten Pakete, aus denen sich das AWT
zusammen setzt:
Paket
Beschreibung
Java.awt
Alle Klassen zum Erstellen von Benutzeroberflächen sowie für das Zeichnen von Grafiken und Bildern
Java.awt.color
Klassen für Farbräume
Java.awt.datatransfer
Schnittstellen und Klassen für die Übertragung von Daten zwischen und innerhalb von Anwendungen
Java.awt.dnd
Drag&Drop Funktionalität
Java.awt.event
Schnittstellen und Klassen für die Ereignisbehandlung
Java.awt.font
Schnittstellen und Klassen für Schriften
Java.awt.geom
Klassen für 2D-Zeichenoperationen
Java.awt.im
Schnittstellen und Klassen für die Behandlung von Eingaben
Java.awt.image
Schnittstellen und Klassen für das Erstellen und Bearbeiten von Bildern
Java.awt.print
Schnittstellen und Klassen für eine allgemeine Drucker-API
Javax.swing
Ergänzung und Erweiterung der AWT-Bibliothek
III.9.2 Bilder laden und ausgeben
Zum Laden eines Bildes von der Festplatte benötigt man ein sogenanntes Toolkit, eine Systemklasseninstanz, welche die
Verbindung zum Betriebssystem herstellt. Eine solche Instanz liefert die statische methode Toolkit.getdefaultToolkit().
Mit der getImage()-Methode von Toolkit kann man dann das Bild laden. Hier ein Beispiel als Grundprogramm:
/* Programm analog zu
* R.Steyer Java2 S. 542 kap 45 */
import java.awt.*;
import java.awt.event.*;
class Bild extends Frame {
Image bild;
public Bild() {
// evt. Hintergundfarbe setzen: setBackground(Color.yellow);
addWindowListener(new WindowAdapter() {
//
public void windowClosing(WindowEvent e) { //zum Schließen des Fensters
dispose();
//unbedingt notwendig!!!
System.exit(0);
//
}
});
// ein Bild wird geladen
bild = java.awt.Toolkit.getDefaultToolkit().createImage("Bild1.jpg");
}
public static void main(String args[]) {
System.out.println("Starting Bild...");
Bild mainFrame = new Bild();
mainFrame.setSize(1024, 768);
mainFrame.setTitle("Bild");
mainFrame.setVisible(true);
}
Html, JavaScript und Java
- 41 -
15. Februar 2005 / 17:55:55
public void paint(Graphics g) {
// Ausgabe des Bildes
g.drawImage(bild, 30, 20, this);
}
}
III.9.3 Das Grundgerüst einer grafischen Benutzeroberfläche
Das folgende Grundgerüst erstellt das Hauptfenster, zeigt es an und beendet das Programm, wenn der Benutzer das
Fenster schließt:
/* Einfache Vorlage für GUI-Anwendungen
* aus Louis Müller S. 431
*/
import java.awt.*;
import java.awt.event.*;
public class GrundgeruestAWT extends Frame {
// Hier Variablen für Komponenten deklarieren
public GrundgeruestAWT() {
super();
// Hauptfenster einrichten
setTitle("Grundgeruest");
setBackground(Color.LIGHT_GRAY);
// Hier Komponenten einfügen
// Fenster schließen
addWindowListener(new WindowLauscher());
}
// Hier Ereignisbehandlungsmethoden für Komponenten
// Fenster und Anwendung schließen
protected static final class WindowLauscher extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public static void main(String args[]) {
// Fenster erzeugen und anzeigen
GrundgeruestAWT hauptfenster = new GrundgeruestAWT();
hauptfenster.setSize(800,400);
// oder pack()
hauptfenster.setLocation(200,200);
hauptfenster.show();
}
}
Quellcodeanalyse:
• Die import-Anweisung führt die Namen der AWT-Klassen ein
• mit public class GrundgeruestAWT extends Frame wird die Hauptklasse der Anwendung deklariert. Diese ist
gleichzeitig die Klasse des Hauptfensters und deshalb von der AWT-Klasse Frame abgeleitet.
• Der Aufruf setTitle() legt fest, welcher Text in der Titelleiste des Programmfensters erscheint
• Mit setbackground(Color.LIGHT_GRAY) wird die Hintergrundfarbe (hellgrau) festgelegt
• Mit protected static final Class ... wird eine interne Hilfsklasse definiert, deren Methode windowClosing()
ausgeführt wird, wenn der Benutzer das Fenster durch Drücken der Schließen-Schaltfläche schließt. Da es sich um
das Hauptfenster handelt, wird in diesem Falle gleich das ganze Programm beendet (System.exit(0)).
• Um die Klasse mit der Ereignisbehandlungsmethode mit dem Fenster zu verbinden, wird oben im Konstruktor des
Fensters die Methode AddWindowListener() mit einer Instanz der Klasse als Argument aufgerufen.
• Die Methode main() konfiguriert das Hauptfenster. Es legt die anfängliche Größe mit (800x400) Bildpunkten und
positioniert die linke obere Ecke an die Stelle (200,200) und zeigt es mit der Anweisung hauptfenster.show() an .
Html, JavaScript und Java
- 42 -
15. Februar 2005 / 17:55:55
Um das Grundgerüst zu einer funktionalen Benutzeroberfläche zu erweitern, kann man die erforderlichen Komponenten
einfügen und Behandlungsroutinen für die von den Komponenten ausgelösten Ereignisse implementieren.
Zwei weitere Beispiele für ein knappes Grundgerüst zur Anzeige eines leeren Fensters. Das erste Programm benötigt
allerdings eine weitere Klasse, nämlich WindowClosingAdapter.class im lokalen Verzeichnis.
/* GrafikBeispiel.java */
import java.awt.*;
import java.awt.event.*;
public class GrafikBeispiel extends Frame
{
public GrafikBeispiel()
{
super("GrafikBeispiel");
addWindowListener(new WindowClosingAdapter(true));
setBackground(Color.lightGray);
setSize(300,200);
setVisible(true);
}
public void paint(Graphics g)
{
//wird in den folgenden Beispielen überlagert
}
public static void main(String[] args)
{
GrafikBeispiel wnd = new GrafikBeispiel();
}
}
2. Beispiel
import java.awt.Frame;
import java.awt.event.*;
public class ZweiterRahmen extends Frame
{
public ZweiterRahmen()
{
setTitle("Dies ist der zweite Rahmen");
setSize(300,200);
/********************************
* HIER IST DER NEUE TEIL ZUM *
* SCHLIESSEN DES RAHMENS!!! *
*******************************/
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}
public static void main(String[] args)
{
Frame rahmen = new ZweiterRahmen();
rahmen.show();
}
}
III.9.3.1 Umfangreicheres Beispiel (Telefon)
Das Programm Telefon eine soll eine Erweiterung des Grundgerüsts aufzeigen. Das Programm simuliert die Tasten eines
Telefons mit Hilfe von Schaltflächen und zeigt die gewählte Nummer in einem Beschriftungsfeld an:
/*
* Telefon.java - Programmieren mit Komponenten
*
*/
Html, JavaScript und Java
- 43 -
15. Februar 2005 / 17:55:55
import java.awt.*;
import java.awt.event.*;
public class Telefon extends Frame {
// Hier Variablen für Komponenten deklarieren
// Ereignisempfänger
ButtonListener butLis = new ButtonListener();
// Bezeichnungsfeld für Anzeige der Telefonnummer
Label nlabel = new Label();
// Grundfläche für Tastatur
Panel tpanel = new Panel();
// Grundfläche für Telefonnummer
Panel npanel = new Panel();
// Zeichenfolge für eingegebene Telefonnummer
String telnum;
public Telefon() {
super();
// Hauptfenster einrichten
setTitle("Telefon-Tastatur");
setBackground(Color.LIGHT_GRAY);
// Layout für Container festlegen
setLayout(new BorderLayout());
// Tasten für Telefontastatur:
Button taste1 = new Button("1");
Button taste2 = new Button("2");
Button taste3 = new Button("3");
Button taste4 = new Button("4");
Button taste5 = new Button("5");
Button taste6 = new Button("6");
Button taste7 = new Button("7");
Button taste8 = new Button("8");
Button taste9 = new Button("9");
Button taste0 = new Button("0");
Button tstern = new Button("*");
Button traute = new Button("#");
Button tclear = new Button("C");
// Telefontasten in Panel für Tastatur einfügen:
tpanel.setLayout(new GridLayout(5, 0, 5, 5));
tpanel.add(taste1);
tpanel.add(taste2);
tpanel.add(taste3);
tpanel.add(taste4);
tpanel.add(taste5);
tpanel.add(taste6);
tpanel.add(taste7);
tpanel.add(taste8);
tpanel.add(taste9);
tpanel.add(tstern);
tpanel.add(taste0);
tpanel.add(traute);
tpanel.add(tclear);
// Ereignisempfänger registrieren
taste1.addActionListener(butLis);
taste2.addActionListener(butLis);
taste3.addActionListener(butLis);
taste4.addActionListener(butLis);
taste5.addActionListener(butLis);
taste6.addActionListener(butLis);
taste7.addActionListener(butLis);
taste8.addActionListener(butLis);
taste9.addActionListener(butLis);
taste0.addActionListener(butLis);
tclear.addActionListener(butLis);
tstern.addActionListener(butLis);
traute.addActionListener(butLis);
Html, JavaScript und Java
- 44 -
15. Februar 2005 / 17:55:56
// Bezeichnungsfeld für Telefonnummer
npanel.setLayout(new GridLayout());
// Anfänglich leeres Bezeichnungsfeld anzeigen
telnum = "";
nlabel.setText(telnum);
// Ausrichtung für Bezeichnungsfeld festlegen
nlabel.setAlignment(Label.LEFT);
// Bezeichnungsfeld in Panel einfügen
npanel.add(nlabel);
// Grundflächen in Frame hinzufügen
add(tpanel, BorderLayout.CENTER);
add(npanel, BorderLayout.SOUTH);
// Fenster schließen
addWindowListener(new WindowLauscher());
}
// Hier Ereignisbehandlungsmethoden für Komponenten
// Schaltflächenklicks auswerten
class ButtonListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String s;
// Befehlszeichenfolge von Taste übernehmen
s = e.getActionCommand();
// Zu bisheriger Telefonnummer hinzufügen
telnum = telnum + e.getActionCommand();
// Falls "C" gedrückt, Nummer löschen
if (s == "C") telnum="";
nlabel.setText(telnum);
}
}
// Fenster und Anwendung schließen
protected static final class WindowLauscher extends WindowAdapter {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
}
public static void main(String args[]) {
// Fenster erzeugen und anzeigen
Telefon hauptfenster = new Telefon();
hauptfenster.setSize(180,200);
hauptfenster.setLocation(200,300);
hauptfenster.show();
}
}
III.9.3.2 Text in Grafikfenstern
Im ersten Beispiel wird ein String zentriert im Ausgabefenster auf einem Panel ausgegeben:
import java.awt.*;
import java.awt.event.*;
public class SimplePanel extends Frame
{
/*****************
* Konstruktor *
****************/
public SimplePanel()
{
setTitle("Einfaches Panel");
setSize(500,400);
addPanel();
addWindowListener(new WindowAdapter()
{
Html, JavaScript und Java
- 45 -
15. Februar 2005 / 17:55:56
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
}
/*******************************
* Panel + Label hinzufuegen *
******************************/
public void addPanel()
{
Panel panel = new Panel();
add(panel);
panel.add(new Label("Text im Panel"));
setBackground(Color.lightGray);
}
/****************
* Startpunkt *
***************/
public static void main(String[] args)
{
Frame rahmen = new SimplePanel();
rahmen.pack();
rahmen.show();
}
}
Das folgende Programm zeigt eine weitere Möglichkeit für eine Textausgabe:
/*
*Textausgabe aus GrafikBeispiel.java mit Einbau Textausgabe.inc+
* WindowClosingAdapter analog zu G.Krüger S. 517*/
import java.awt.*;
import java.awt.event.*;
public class Textausgabe1 extends Frame
{
public Textausgabe1()
{
super("Textausgabe1");
addWindowListener(new WindowClosingAdapter(true));
setBackground(Color.lightGray);
setSize(600,400);
setVisible(true);
}
/* Textausgabe.inc */
public void paint(Graphics g)
{
int maxX=getSize().width-getInsets().left-getInsets().right;
int maxY=getSize().height-getInsets().top-getInsets().bottom;
g.setFont(new Font("TimesRoman",Font.BOLD,24));
// oder auch
//g.setFont(new java.awt.Font("TimesRoman",java.awt.Font.BOLD,18));
g.drawString(
"Die Client-Area ist "+maxX+"*"+maxY+" Pixel groß",
getInsets().left + maxX/8,
getInsets().top + maxY/2
);
}
public static void main(String[] args)
{
Textausgabe1 wnd = new Textausgabe1();
}
}
III.9.3.3 Fonts
Im folgenden Programm werden Auswahl und Veränderung von Fonts beschrieben.
/* Programm analog zu R.Jesse Java2 S. 378 */
import java.awt.*;
import java.awt.event.*;
Html, JavaScript und Java
- 46 -
15. Februar 2005 / 17:55:56
class FontDemoPanel extends Panel
{
private Font f1, f2, f3;
// Schriftartten festlegen
public void setFonts(Graphics g)
{
f1 = new Font("serif",Font.PLAIN,20);
f2 = new Font("sanserif",Font.BOLD,20);
f3 = new Font("Dialog",Font.ITALIC,20);
}
public void paint(Graphics g)
{
setFonts(g);
String str = "Fontdemo";
g.setFont(f1);
g.drawString(str, 50,50);
g.setFont(f2);
g.drawString(str, 50,80);
g.setFont(f3);
g.drawString(str, 50,110);
}
}
/***********************************
* Klasse fuer das Rahmenfenster *
**********************************/
class FontDemoFrame extends Frame
{
//
public FontDemoFrame()
{
setTitle("FontDemo");
setSize(300,400);
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
// Panel zum Rahmen hinzufuegen
add(new FontDemoPanel());
}
}
/***************************
* HAUPTKLASSE *
**************************/
public class FontDemo
{
// Startpunkt des Beispiels
public static void main(String[] args)
{
Frame rahmen = new FontDemoFrame();
rahmen.show();
}
}
III.9.3.4 Elementare Grafikroutinen
Um die Grafikfähigkeiten von Java nutzen zu können, muss das paket java.awt mit import java.awt.*; eingebunden
werden. Die Klasse Graphics aus dem Paket java.awt stellt neben vielen anderen Funktionen auch eine Sammlung von
Zeichenoperationen zur Verfügung. Es gibt Methoden zum Zeichnen von Linien, Kreisen, Ellipsen, Bögen, Rechtecken,
Polygonen, Text und Bildern. Die Ausgabe in ein Fenster erfolgt durch Überlagern der Methode paint , die immer dann
aufgerufen wird, wenn das Fenster neu oder teilweise neu gezeichnet werden muss. Paint bekommt beim Aufruf eine
Instanz der Klasse Graphics übergeben. Das obige Beispiel GrafikBeispiel.java dient als Rumpfprogramm zur
Aufnahme der jeweiligen paint-Methode. Voraussetzung für seine Verwendung ist die Existenz der Datei
WindowClosingAdapter.java im aktuellen Verzeichnis.
Html, JavaScript und Java
- 47 -
15. Februar 2005 / 17:55:56
Das graphische Koordinatensystem:
Die Ausgabe von Grafik basiert auf einem zweidimensionalen Koordinatensystem, dessen Ursprung (0,0) in der linken
oberen Ecke des Fensters liegt. Positive x-Werte erstrecken sich nach rechts, positive y-Werte nach unten. Die
Maßeinheit entspricht einem Pixel. Mit der Methode getinsets kann die Größe von vorhandenen Randelementen
ermittelt wertden.
Linien/Figuren zeichnen:
public void drawLine(int x1, int y1, int x2, int y2)
zieht eine Linie von der Position (x1,y1) nach (x2,y2).
public void drawRect(int x, int y, int width, int height)
zeichnet ein Rechteck der Breite width und der Höhe height, dessen linke obere Ecke an der Position (x,y) liegt.
public void drawPolygon(int[] arx, int[] ary, int cnt)
zeichnet Linienzüge und erwartet 3 Parameter: der erste ist ein Array mit einer Liste der x-Koordinaten, der zweite ein
Array mit den y-Koordinaten. Die Anzahl der gültigen Koordinatenpaare wird durch den dritten Parameter festgelegt.
Sollen Anfangs- und Endpunkt nicht geschlossen werden, so kann der Befehl
public void drawPolyline(int[] arx, int[] ary, int cnt)
public void drawOval(int x, int y, int width, int height)
zeichnet Kreise und Ellipsen in ein Rechteck der Größe width, height mit der linken oberen Ecke in (x,y).
public void drawArc(int x, int y, int width, int height,int startAngle, int arcAngle))
zeichnet einen Kreisbogen.
Linien-und Füllmodus:
Mit Ausnahme von drawLine können alle Routinen entweder im Linien- oder Füllmodus verwendet werden. Beginnt der
Methodenname mit draw, so erfolgt die Ausgabe im Linienmodus. Begoinnt der Methodenname mit fill, so erfolgt die
Ausgabe im Füllmodus.
Löschen:
Löschen:
public void clearRect(int x, int y, int width, int height)
löscht einen rechteckigen Ausschnitt.
Html, JavaScript und Java
- 48 -
15. Februar 2005 / 17:55:57
III.10 JAVA und SOUND
Die java-Bibliothek bietet eine recht brauchbare Sound-API. Von den unzähligen Dateiformaten unterstützt java die
Formate wav, mid , au und Rmf.
Das Abspielen von Sound war in früheren java-Versionen nur in Applets möglich. Neuerdings ist das Abspielen von
Sound-Dateien auch in Applicationen möglich, allerdings nur unter Verwendung der Applet-Klasse (Paket java.applet)
Die zentrale Stelle bildet hierbei AudioClip mit folgenden Methoden zum Abspielen von Klangdateien:
play()
loop()
stop()
spielt die Klangdatei ab
spielt die Klangdatei in einer Endlosschleife
Stoppt das Abspielen
Vor dem Abspielen muss die Klangdatei geladen werden. Hierzu bietet die Klasse Applet folgende 2 Methoden an.
Dabei kann ein Applet nur getAudioClip() und eine Application nur newAudioClip() verwenden.
public AudioClip getAudioClip(URL url)
public static AudioClip newAudioClip(URL url)
Die Methoden erwarten die Dateien als URL , d.h. Beim Laden von lokalen Dateisystemen muss file:/// vor den
Filenamen vorangestellt werden und das Ganze mit new URL(URL „Filename“) in einen URL umgewandelt werden.
Dazu muss das Paket java.net.* bzw. java.net.URL importiert werden.
Das Laden und Spielen einer Datei ist somit mit wenigen Zeilen erledigt:
//..
AudioClip clip = null;
try
{
clip = Applet.newAudioClip(new URL(„file:///H:/hello.au“));
}
catch(Exception e)
{
System.out.println(e);
}
if (Clip != null)
clip.play();
Zu beachten ist allerdings, dass beim Anlegen einer URL-Instanz eine Exception vom Typ MalformedURLException
ausgelöst werden kann, so dass ein geeigneter try-catch-Block notwendig ist.
Tipp: Beim Einsatz von AudioClip wird die abzuspielende Datei komplett in den Hauptspeicher des Rechners geladen,
sodass der Beginn des Abspielens entsprechend lange dauern kann.
Html, JavaScript und Java
- 49 -
15. Februar 2005 / 17:55:57
III.11 Applets
III.11.1 Applet-Grundgerüst
In den bisherigen Kapiteln wurde nur über Java-Applikationen gesprochen. Ihr besonderes Merkmal ist, dass sie
selbständig lauffähig sind, d.h. hierfür verwendet man den Java-Interpreter java.exe.
Bei Applets verhält es sich anders: Sie benötigen immer einen Internet-Browser, der java-fähig ist. Mit dem Programm
appletviewer.exe von SUN lassen sich Java-Applets ebenfalls darstellen.
Die Erzeugung eines Applets unterscheidet sich nicht wesentlich von der Erzeugung von Applikationen. Als
Einstiegsbeispiel soll wieder das berüchtigte „HelloWorld“ dienen. Dieses wollen wir als Applet realisieren. Folgende
Schritte sind auszuführen:
1. Erzeugen einer Datei mit einem beliebigen Text-Editor mit der Endung .java. (hier. HelloWorldApplet.java)
/**
* Dieses Beispiel zeigt den grundsaetzlichen Aufbau eines Applets in Java. Es dient nur
* zur Ausgabe eines Textes auf dem Bildschirm.*/
import java.applet.Applet; // oder import java.applet.*;
import java.awt.Graphics;
public class HelloWorldApplet extends java.applet.Applet
{
// Einstiegspunkt in das Applet
public void paint(Graphics g)
{
// Ausgabe des Textes
g.drawString("Hello World!", 50, 25);
}
}
2. Kompilieren der Datei wie bei Applikationen mit dem javac Compiler zu „ HelloWorldApplet.class“.
3. Erstellen der zum Applet gehörigen Html-Datei:
<html>
<body>
<applet code = "HelloWorldApplet.class" width = 350 height = 300 >
</applet>
</body>
</html>
4. Starten des Applets durch Aufruf der Html-Seite mit dem Applet-Tag
Zu beachten sind einige wesentliche Unterschiede zu den Applikationen:
1. Es gibt keine main-Methode mehr. Anstelle der main-Methode tritt die Methode paint.
Damit ein Applet gestartet werden kann, gibt es 3 mögliche Startpunkte: Die Methoden start, init und paint.
Die hier verwendete Methode paint erfordert ein Argument, das von der Graphics-Klasse abgeleitet ist. In
unserem Beispiel hat dieses Objekt den Namen g und wird vom Browser zur Verfügung gestellt. Mit diesem
Objekt wird nun die Methode drawString() verbunden und in der Klasse java.awt.Graphics folgendermaßen
definiert:
abstract void drawString(String str, int x, int y)
Es müssen also 3 Argumente an diese Methode übergeben werden. Voraussetzung hierfür ist, dass diese
Klasse zu Beginn importiert wird.
2. Jedes Applet muss eine Sub-Klasse der Applet-Klasse von Java definieren. Dies wird durch das Importieren
von java.applet.Applet; ermöglicht. Die Applet-Subklasse wird dann durch class HelloWorldApplet extends
Applet erzeugt. Auf diese Weise erbt das Applet HelloWorldApplet die gesamte Funktionalität eines
Applets.
3. Die Vererbung von Klassen wird durch das Schlüsselwort extends eingeleitet. HelloWorldApplet erbt damit
alle Eigenschaften der Superklasse Applet. In den anschließenden geschweiften Klammern kann die
Funktionalität der Klasse Applet erweitert werden. Es können also neue Eigenschaften und Methoden
hinzugefügt werden, die aber nur für die abgeleiteten Klassen gelten.
Html, JavaScript und Java
- 50 -
15. Februar 2005 / 17:55:57
III.11.2 Lebenszyklus eines Applets
Der Basiscode eines Applets ist damit noch nicht vollständig, denn ein Applet besitzt einen eigenen Lebenszyklus. Es
gibt eine Initialisierungsphase (init() ), eine Startphase (start() ), eine Stoppphase (stop() ) und eine Auflösungsphase
(destroy() ). Diese 4 Zustände eines Applets sollten auch in den Code integriert werden. Dazu existieren eigene
Methoden, in denen ein bestimmter Code ablaufen kann.
Die Methoden werden folgendermaßen in den Quelltext eingebaut und vom Interpreter automatisch aufgerufen:
import java.applet.*;
import java.awt.*;
public class LebensZyklusBsp extends Applet
{
String textausgabe=new String ("Hello init usw.");
public void init()
{
}
public void start()
{
}
public void stop()
{
}
public void destroy()
{
}
public void paint(Graphics g)
{
g.drawString(textausgabe, 50, 50);
}
}
III.11.3 Das Arbeiten mit Parametern bei Applets
Im folgenden Beispiel wird gezeigt, wie ein Applet über sogenannte <PARAM>-Tags auf der HTML-Seite gesteuert
werden kann.Es wird dabei in einem <PARAM>-Tag ein Ausgabetext angegeben, der dann im Applet angezeigt werden
soll. Dazu wird der HTML-Code um ein <PARAM>-Tag mit Bezeichnung(=NAME) und Inhalt(=VALUE) erweitert :
<Applet Code="AppletMitParameter.class" Width=400 Height=300>
<PARAM NAME="ausgabe" VALUE="Text aus der HTML-Seite ins Applet einlesen!">
</Applet>
Der JAVA-Code sieht dazu folgendermaßen aus (-> Prog5):
import java.applet.*;
import java.awt.*;
public class AppletMitParameter extends Applet
{
String textausgabe=new String();
// Initialisierung des Applets
public void init()
{
textausgabe=getParameter("ausgabe");
}
// Ausgaben des Applets
public void paint(Graphics g)
{
g.drawString(textausgabe, 50,50);
}
}
Html, JavaScript und Java
- 51 -
15. Februar 2005 / 17:55:57
Sollen mehrere Texte im Applet ausgegeben werden, die über <PARAM> eingelesen werden sollen, muss der HTMLund der JAVA-Code erweitert werden. Jeder einzelne Text muss durch einen eigenen <PARAM>-Tag angegeben
werden. (-> Prog6)
III.11.4 Das Event-Modell über Listener
Grafische Benutzeroberflächen arbeiten ereignisgesteuert. Das heißt, das zugrunde liegende Betriebssystem überwacht
die Umgebung ständig auf Ereignisse, wie Tastenbetätigung oder Mausklicks und meldet diese an die laufenden
Programme. Für die eigentliche Ereignisverarbeitung sind die einzelnen Programme zuständig. Ereignisse werden ab
JDK 1.1 über sogenannte Listener programmiert. Für jeden Ereignistyp muss ein eigener Listener erstellt werden, der
die Ereignisse überwacht, beobachtet und entsprechende Methoden aufruft. Beispielsweise ist für alle Mausaktivitäten
der MouseListener zuständig, für Tastatureingaben ist der KeyListener vorhanden und für Ereignisse rund um das
Fenster benötigt man den WindowListener.
Welche Listener1 gibt es?
•
KeyListener
für Tastaturereignisse
•
WindowListener
für Fensterereignisse
•
MouseListener
für Mausereignisse
•
MouseMotionListener für spezielle Mausereignisse
•
ActionListener
für die Klassen Button, List, MenuItem und TextField
•
ItemListener
für Kontrollkästchen Checkbox, CheckboxMenuItem, Choice und List
Prinzipielle Vorgehensweise bei der Anwendung von Listener:
• Am Anfang der Datei bzw. Klasse muss das paket java.awt.event.* importiert werden
• In der Klassendefinition fügt man den entsprechenden Listener über implements XXX
hinzu, wobei XXX für den entsprechenden Listener steht (z.B. implements
WindowListener)
• Innerhalb der Konstruktorfunktion fügt man den Listener der jeweiligen Komponente über
die Methode addXXXListener() hinzu, wobei XXX für den entsprechneden Listener steht;
(z.B. addWindowListener())
• Innerhalb der Klasse fügt man sämtliche Methoden des Listeners hinzu, die in dem
entsprechneden Interface definiert sind. (s. Dokumentation zu Java)
Ein Beispiel, wie auf einen Button reagiert wird: Dazu gibt es für das Klickereignis von Schaltflächen die Schnittstelle
ActionListener mit der alleinigen Methode actionPerformed().
public void actionPerformed (ActionEvent e)
{
if (e.getSource() == knopfname1)
{ Anweisungen }
else
if (e.getSource() == knopfname2)
{ Anweisungen }
} ...
Im folgenden Kapitel III.11.5 befindet sich ein weiteres Beispiel für einen ActionListener in einem Applet.
1
Insgesamt gibt es im API 68 Listener Interfaces
Html, JavaScript und Java
- 52 -
15. Februar 2005 / 17:55:57
III.11.5 Sound mit der Klasse Applet
Zur Speicherung von Klängen existieren unzählige Dateiformate. Java unterstützt leider nur einen Bruchteil davon. Es
können nur lineare PCM2-Daten in den Formaten WAV, AU, AIFF, MID und RMF abgespeilt werden.
Das Apspielen von Sound war in früheren SDK Versionen nur mit Applets möglich und wurde später auch für normale
Applikationen zugänglich gemacht. Daher erklärt sich der Umstand, dass eine Applikation zum Abspielen von Sound
mit der Applet-Klasse (Paket java.applet) arbeiten muss.
Die zentrale Schnittstelle bildet hierbei AudioClip mit den 3 Methoden play(), loop() und stop(). Das Abspielen erfolgt
dabei in einem separaten Thread3. Dadurch kann man auch mehrere Dateien gleichzeitig abspielen. Um eine Klangdatei
zu laden gibt es die Methoden
public AudioClip getAudioClip(URL url)
und
public static AudioClip newAudioClip(URL url)
Während getAudioClip() nur in Applets verwendbar ist, muss bei Applikationen newAudioClip() genommen werden.
Die Methoden erwarten die Datei als URL, d.h. Beim Laden von lokalen Dateien muss file:/// vorangestellt werden.
Das Laden und Spielen von Dateien ist somit in wenigen Zeilen erledigt:
1. Beispiel für eine Applikation:
import java.net.*;
import java.applet.*;
public class PlaySound
{
public static void main(String[] args)
{
try
{
URL url = new URL("file:"+"piano1.wav"); /*statt "file:///H:/Schule/Informatik/Java/Eigene
Programme/Java/Prog28/Version4/piano1.wav" */
AudioClip clip = Applet.newAudioClip(url);
clip.play();
try
{
Thread.sleep(10000);
}
catch (InterruptedException e)
{
}
System.exit(0);
}
catch (MalformedURLException e)
{
System.out.println("Fehler im Dateinamen: "+e.toString());
}
}
}
2. Beispiel für ein Applet: ( -> Prog8 )
/* HWApplet.java
*
* zur Demonstration einer *
* Sounddatei
*/
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class AppletSoundMinimal extends Applet
implements ActionListener
{
Button hello;
AudioClip helloClip;
public void init()
{
2
3
PCM = PulsCodeModulation
Als Thread bezeichnet man ein Programmteil, der zeitlich unabhängig von anderen Programmteilen abläuft, und eine Klasse,
mit der solche Abläufe gesteuert werden können; vom englischen Wort für Faden.
Html, JavaScript und Java
- 53 -
15. Februar 2005 / 17:55:57
hello = new Button("Hello");
hello.addActionListener(this);
add(hello);
helloClip = getAudioClip(getCodeBase(),"hello.au");
}
public void actionPerformed(ActionEvent event)
{
String cmd = event.getActionCommand();
if (cmd.equals("Hello")) {
helloClip.play();
}
}
}
Neben den einfachen Sound-Fähigkeiten im Paket java.applet gehört zu Java seit der JDK-Version 1.3 eine recht
leistungsfähige Sound Engine und eine entsprechende Bibliothek in Form mehrerer Pakete, vor allem
javax.sound.sampled.4
III.12 Klassen programmieren
Der erste Schritt bei der objektorientirten Programmerstellung ist die Zerlegung des Problems in geeignete Objekte und
die Festlegung ihrere Eigenschaften und Verhaltensweisen, d.h. Der Eigenschaften und der Methoden, die diese Objekte
haben sollen. Wir wollen nun an einem konkreten Beispiel eine eigene Klasse erstellen und deren Verwendung uns
anschauen.
Eine neue Klasse erstellen
Für eine Firma soll ein Programm zur Verwaltung der Mitarbeiter erstellt werden. Eine naheliegende Lösung ist, die
Mitarbeiter als die Objekte anzusehen. Schaffen wir also den Prototyp eines Mitarbeiters und implementieren wir diesen
in Form der Klasse CMitarbeiter5.
class CMitarbeiter
{
}
Nun müssen wir unserer Klasse noch Eigenschaften und Methoden zuweisen.
Eigenschaften von Klassen
Der Mitarbeiter hat natürlich neben einem Namen auch einen Vornamen und er kriegt ein Gehalt6.
class CMitarbeiter
{
String m_name;
String m_vorname;
int m_gehalt;
}
// Monatsgehalt
Diese Variablen, die innerhalb einer Klasse, aber außerhalb aller Methoden der Klasse deklariert werden, nennt man
Instanzvariablen. Alle Methoden der Klasse können auf diese Variablen zugreifen.
Das Programm soll nun folgende Aufgaben erfüllen:
•
die persönlichen Daten eines Mitarbeiters ausgeben
•
sein Gehalt erhöhen
4
5
6
s.a. Louis/Müller Java2 S. 635 ff.
Alle eigenen Klassen sollen mit C beginnen, um sie von Klassen von java besser zu unterscheiden
Im Gegensatz zu int ist String selbst eine Klasse, um Zeichenketten aufzunehmen und zu verarbeiten
Html, JavaScript und Java
- 54 -
15. Februar 2005 / 17:55:58
Methoden von Klassen
Persönliche Daten ausgeben und Gehalt erhöhen sind Aktionen, die auf den Daten des Mitarbeiters operieren. Folglich
werden diese als Methoden der Klasse CMitarbeiter implementiert.
class CMitarbeiter
{
String m_name;
String m_vorname;
int m_gehalt;
// Monatsgehalt
//Klasse
CMitarbeiter(String pName, String pVorname, int pGehalt)
{
m_name = pName;
m_vorname = pVorname;
m_gehalt = pGehalt;
}
//Konstruktor
void datenAusgeben()
{
System.out.println("\n");
System.out.println("Name : " + m_name);
System.out.println("Vorname : " + m_vorname);
System.out.println("Gehalt : " + m_gehalt +
" €");
}
//Methode1
void gehaltErhoehen(int pErhoehung)
{
m_gehalt += pErhoehung;
}
} // Ende der Klassendeklaration
//Methode2
Die Klasse CMitarbeiter besitzt nun 3 Methoden mit den Namen CMitarbeiter, datenAusgeben und gehaltErhoehen.
Zusammenfassung: Was gehört zur Definition einer Methode alles dazu?
1. Zuerst braucht die Methode einen Namen
2. Anweisungen in der Methode, die bei Aufruf ausgeführt werden können
3. Auf den Methodennamen sollen 2 Klammern folgen, damit der Compiler schnell erkennen kann, dass ein
Name eine Methode bezeichnet.
Unsere Methodendeklaration sieht also folgendermaßen aus:
methodenName()
{
}
Mittlerweile kennen wir 3 Arten von Bezeichnern: Variablennamen, Namen für selbst definierte Klassen und
Methodennamen.
Woher nimmt aber die Methode die Daten, mit denen sie arbeitet?
•
Die Methode kann auf alle Instanzvariablen ihrer Klasse zugreifen
•
Eine Methode kann auch eigene lokale Variablen definieren. Diese lokalen Variablen sind keine Klassenelemente,
folglich können sie nicht in jeder beliebigen Methode der Klasse benutzt werden, sondern nur innerhalb der
Methode, in der sie deklariert sind.
•
Für den Austausch über Klassengrenzen hinweg gibt es sogenannte Parameter. Das sind Variablen, die innerhalb der
Klammern der Methodendeklaration stehen. Bei Aufruf der Methode werden diesen Parametern Werte übergeben,
die dann innerhalb der Methode wie lokale Variable benutzt werden können.
•
Schließlich soll die Methode noch Daten nach außen exportieren. Zu diesem Zweck definiert jede Methode einen
Rückgabewert, dessen Datentyp vor den Methodennamen gestellt wird. Mit Hilfe des Schlüsselwortes return wird
dieser Rückgabewert an den Aufrufer der Methode zurückgeliefert. Eine vollständige Methodendeklaration würde
jetzt folgendermaßen aussehen:
Rückgabetyp methodenName(Deklaration_der_Parameter)
{
lokale Variablen;
Anweisungen;
Html, JavaScript und Java
- 55 -
15. Februar 2005 / 17:55:58
}
Schauen wir uns die beiden Methoden datenAusgeben() und gehaltErhoehen() an. Die leeren Klammern besagen, dass
keine Parameter übergeben werden. Das void zeigt an, dass auch kein Wert zurückgegeben wird. Innerhalb der Methode
kann bei System.out.println() als Parameter ein auszugebender Text oder Variablen der Datentypen String übergeben
werden. Bei der Methode gehaltErhoehen(int pErhoehung) wird über die int-Variable pErhoehung die Erhöhung zum
aktuellen Gehalt addiert.
Konstruktoren von Klassen
Die Methode, die den gleichen Namen trägt wie die ganze Klasse
CMitarbeiter(String pName, String pVorname,
int pGehalt)
{
m_name = pName;
m_vorname = pVorname;
m_gehalt = pGehalt;
}
ist eine ganz besondere Methode, nämlich ein Konstruktor. Jede Klasse braucht einen Konstruktor, der beim
Initialisieren der Variablen (Objekte) der Klasse behilflich ist. In unserem Fall übergeben wir die persönlichen Daten
des Mitarbeiters an den Konstruktor, der sie den richtigen Variablen zuweist.
Jede Klasse braucht also einen Konstruktor zur Initialisierung ihrer Instanzvariablen.
Verwendung der eigenen Klassen
Nun wollen wir die Klasse auch benutzen. Wir nehmen das Grundgerüst für ein Java-Programm, fügen die
Klassendefinitonen von Mitarbeiter hinzu und erzeugen dann in der main()-Methode einige Instanzen unserer neuen
Klassen.
Bisher ist unsere Klasse CMitarbeiter keine Variable, sondern stellt nur einen neuen Datentyp dar. Der Wertebereich
dieser Klasse ist nicht irgendeine Zahl, sondern die Instanz7, die wir mit Hilfe des Konstruktors der Klasse erzeugen.
In der main()-Methode werden die Instanzen der Klasse CMitarbeiter angelegt:
CMitarbeiter billy = new CMitarbeiter(„Gates“,“Bill“,3000);
Als erstes legt der Compiler eine neue Variable billy an. Die rechte Seite teilt ihm mit, dass er eine neue Instanz der
Klasse CMitarbeiter erzeugen soll. Dazu wird mit Hilfe des Schlüssewortes new der Konstruktor der Klasse aufgerufen,
der drei Parameter erwartet, die wir ihm übergeben.
Zugriff auf die Instanzen
Wie erfolgt nun der Zugriff auf die Instanzen billy und stevie? Man gibt einfach den Namen der Instanz an und den
Namen der gewünschten Methode, getrennt durch den Punkt-Operator.
Billy.datenAusgeben()
Verfügt die Methode über Parameter, werden diesen in der Klammer Argumente übergeben. Wichtig ist hier die gleiche
Reihenfolge, wie in der Definition der Methode!!
Hier das fertige Programm:
public class CMitarbeiterBeispiel
{
public static void main(String[] args)
{
// 2 neue Mitarbeiter instanziieren
CMitarbeiter billy =
new CMitarbeiter("Gates","Bill",3000);
CMitarbeiter stevie =
new CMitarbeiter("Jobs","Steve",3500);
// Daten ausgeben
billy.datenAusgeben();
stevie.datenAusgeben();
// Gehalt von a erhöhen
7
Objekt wird häufig als synonymer Begriff für Instanz bezeichnet
Html, JavaScript und Java
- 56 -
15. Februar 2005 / 17:55:58
billy.gehaltErhoehen(500);
// Kontrolle
billy.datenAusgeben();
stevie.datenAusgeben();
}
}
class CMitarbeiter
{
String m_name;
String m_vorname;
int m_gehalt;
// Monatsgehalt
CMitarbeiter(String pName, String pVorname,
int pGehalt)
{
m_name = pName;
m_vorname = pVorname;
m_gehalt = pGehalt;
}
void datenAusgeben()
{
System.out.println("\n");
System.out.println("Name : " + m_name);
System.out.println("Vorname : " + m_vorname);
System.out.println("Gehalt : " + m_gehalt +
" DM");
}
void gehaltErhoehen(int pErhoehung)
{
m_gehalt += pErhoehung;
}
}
IV Datenbankprogrammierung
V Netzwerkprogrammierung
Exceptions
Java2D
Html, JavaScript und Java
- 57 -
15. Februar 2005 / 17:55:58
VI Glossar
Abstract Windowing Toolkit (AWT)
ein Paket von Java-Klassen für Graphische User-Interfaces, die zur Laufzeit vom lokal
installierten System sichtbar gemacht werden. Der Name bedeutet übersetzt abstrakter
Werkzeugsatz für die Arbeit mit Fenstern.
Applet
ein Java-Programm, das innerhalb eines Web-Browsers abläuft und innerhalb einer Web-Page
dargestellt wird; außerdem die Oberklasse für die Programmierung von solchen Applets.
Applikation
ein Programm, das selbständig auf einem Computer abläuft, im Fall von Java-Programmen
innerhalb der Java Virtual Machine,
Binärprogramm
die von der Computer-Hardware mit Hilfe des Betriebssystems ausführbare Version eines
Programms, wird mit Hilfe des Compilers aus dem für Menschen lesbaren Source-Programm
erzeugt. Im Fall von Java-Programmen enthält das Binärprogramm den Bytecode für die Java
Virtual Machine.
boolean
Datentyp für logische Werte (true oder false), benannt nach dem Wissenschaftler Boole.
byte
Datentyp für ein Byte; das ist die kleinste Einheit, die bei der Ein- und Ausgabe übertragen wird
(8 Bits, entspricht einer Zahl zwischen 0 und 255 oder zwischen -127 und 128).
Bytecode
das vom Java-Compiler erstellte Binärprogramm, das auf allen Computern ausgeführt werden
kann, auf denen eine Java Virtual Machine installiert ist.
char
Datentyp für einzelne Zeichen, vom englischen Wort character für Zeichen.
Common Gateway Interface (CGI)
die Festlegung, wie auf einem Web-Server laufende Programme die vom Client gewünschten
Informationen an den Client senden.
Client
ein Computer oder Programm, das die Informationen oder Dienste bekommen möchte, die auf
einem Server angeboten werden. Der Name kommt vom englischen Wort für Kunde.
Compiler (Übersetzer)
eine Software, die das für Menschen lesbare Source-Programm in das maschinenlesbare
Binärprogramm übersetzt.
Component
die Oberklasse für alle Klassen, die Komponenten von Graphischen User-Interfaces beschreiben.
Container
die Oberklasse für alle GUI-Komponenten, die weitere Komponenten (Components) enthalten
können.
Date
eine Klasse für Zeitpunkte (Datum und Uhrzeit).
Datei
siehe File.
Datenbank
eine Möglichkeit zur Speicherung von großen oder komplexen Datenmengen.
Datenbanksystem
eine Software zur Verwaltung und Benutzung von Datenbanken.
Datenfeld
eine Eigenschaft eines Objekts, die einen bestimmten Wert enthalten kann, oder eine lokale
Variable innerhalb einer Methode, die zur Speicherung eines Zwischenergebnisses dient.
Debugging
Entfernen von Programmfehlern, vom englischen Wort für die Vernichtung von Ungeziefer.
double
Datentyp für Kommazahlen mit normaler Genauigkeit (doppelt so genau wie float), vom
englischen Wort für doppelt.
Exception
eine Ausnahme vom normalen Programmablauf; außerdem eine Klasse, die (mit zahlreichen
Unterklassen) solche Ausnahmen beschreibt.
Event
Html, JavaScript und Java
- 58 -
15. Februar 2005 / 17:55:59
eine Aktion des Benutzers in einem Graphischen User-Interface; außerdem eine Klasse, die (mit
mehreren Unterklassen) solche Ereignisse beschreibt.
equals
die Methode, die Objekte auf gleichen Inhalt untersucht.
Feld (array)
eine Menge von gleichartigen Datenfeldern.
File
eine Klasse für die Verarbeitung von Dateien (Files) und Verzeichnissen (Directories).
float
Datentyp für Kommazahlen mit geringer Genauigkeit (halb so genau wie double); vom
englischen Wort floating point für Fließkomma.
Frame
eine Klasse für Bildschirmfenster in Graphischen User-Interfaces.
Garbage-Collector
ein Programmteil, der den von Objekten nicht mehr benötigten Speicherbereich für neue Objekte
frei macht. Der Name kommt vom englischen Wort für Müllsammler.
Graphisches User-Interface (GUI)
die Möglichkeit, ein Programm mit Tastatur und Maus (oder ähnlichen Geräten) zu bedienen und
Informationen nicht nur zeilenweise, sondern in graphischer Form in Bildschirmfenstern
darzustellen.
Graphics
eine Klasse für graphische Darstellungen.
Hostname
ein Name oder eine Nummer, die einen Rechner innerhalb des Internet oder Intranet eindeutig
bezeichnet. Der Name kommt vom englischen Wort host für Gastgeber.
Hypertext Markup Language (HTML)
das Format, in dem Text-Informationen mit Verknüpfungen in Form von sogenannten
Hypertext-Links über das WWW übertragen werden (siehe auch WWW Was ist das).
Hypertext Transfer Protocol (HTTP)
das Protokoll, nach dem die Übertragung zwischen Web-Servern und Web-Browsern erfolgt.
int
Datentyp für ganze Zahlen im normalen Wertebereich, vom englischen Wort integer für ganz.
InputStream
die Oberklasse für alle Klassen für die Byte-orientierte Eingabe.
Interface (Schnittstelle)
etwas Ähnliches wie eine Oberklasse, in der jedoch nur die Deklarationen der Methoden
festgelegt sind, die von der Unterklasse implementiert werden müssen; erlaubt im Gegensatz zu
Oberklassen auch eine mehrfache Vererbung.
Internet
ein weltweites Netz von miteinander verbundenen Computernetzen. Die Übertragung erfolgt mit
dem Protokoll TCP/IP. Über das Internet laufen viele verschiedene Dienste: Telnet für den
Zugriff auf andere Rechner, File Transfer Protocol (FTP) für die Übertragung von Dateien,
Electronic Mail (E-Mail) für den Austausch von elektronischen Briefen, das World Wide Web
(WWW) für den Zugriff auf Informationssysteme, die Usenet Newsgruppen für Diskussionen,
und viele andere. Der Name Internet kommt von der englischen Bezeichnung interconnected
networks und bedeutet miteinander verbundene Netzstrukturen.
Intranet
ein internes lokales Computernetz, das die gleiche Technologie wie das Internet verwendet. Der
Name kommt vom lateinischen Wort intra für innerhalb und vom englischen Wort network für
Netz.
Iso-Latin-1
ein Zeichensatz, der nur die westeuropäischen Buchstaben, Ziffern und Sonderzeichen umfasst.
Java
eine Insel in Indonesien, eine in Amerika übliche Bezeichnung für Kaffee und eine moderne,
objektorientierte Programmiersprache
Java Bean
ein Java-Programm (Klasse) mit genau festgelegten Konventionen für die Schnittstellen, die eine
Wiederverwendung dieser Klasse in anderen Programmen ermöglichen. Der Name ist ein
Wortspiel, das Kaffeebohne bedeutet.
Java Database Connectivity (JDBC)
eine Schnittstelle für den Zugriff auf Datenbanken von Java-Programmen aus.
Java Development Kit JDK
Html, JavaScript und Java
- 59 -
15. Februar 2005 / 17:55:59
die Software, die für die Erstellung, Übersetzung und Ausführung von Java-Programmen
notwendig ist; enthält unter anderem den Java-Compiler, das Java Runtime Environment JRE
und diverse Hilfsprogramme. Der Name bedeutet übersetzt Java-Entwicklungs-Werkzeug.
Java Runtime Environment JRE
die Software, die für die Ausführung von Java-Programmen notwendig ist; enthält unter anderem
die Java Virtual Machine JVM und die Klassenbibliothek. Der Name bedeutet übersetzt
Java-Laufzeit-Umgebung.
Java Virtual Machine JVM
die Software, die notwendig ist, um ein Java-Binärprogramm (Bytecode) auf einem Computer
auszuführen. Der Name bedeutet virtuelle Java-Maschine und kommt daher, dass der Computer,
der direkt nur Windows- oder Macintosh- oder Unix-Binärprogramme ausführen kann, mit Hilfe
der JVM so wirkt, als ob er Java-Bytecode ausführen könnte, also als ob er eine Java-Maschine
wäre.
Kapselung
der Schutz von Datenfeldern gegen falsche Werte und von programminternen Methoden gegen
falsche Aufrufe durch andere Programme. Dies wird auch als Data-Hiding (Daten verstecken)
bezeichnet.
Klasse
eine Menge von gleichartigen Objekten und ein Programm, das die Eigenschaften von solchen
Objekten beschreibt.
Klassenbibliothek
eine Sammlung von Programmen (Klassen), die für verschiedene Anwendungen eingesetzt
werden können.
Konstruktor
ein Programmteil, der ein Objekt erzeugt, also einen Speicherbereich für ein Objekt bereitstellt
und die Datenfelder des Objekts auf ihre Anfangswerte setzt. Der Name kommt vom englischen
Wort constructor für Baumeister.
Layout-Manager
eine Klasse, die für die Anordnung von GUI-Komponenten in einem Container sorgt.
Listener
eine Klasse, die auf Aktionen des Benutzers (Events) in einem Graphischen User-Interface
wartet.
long
Datentyp für besonders große ganze Zahlen, vom englischen Wort für lang.
Math
eine Klasse für mathematische Funktionen.
Methode
ein Programmteil, der eine Aktion beschreibt, die von einem Objekt oder mit einem Objekt
ausgeführt werden kann; in manchen Programmiersprachen auch als Unterprogramm,
Subroutine, Prozedur oder Funktion bezeichnet.
Oberklasse (Superklasse)
eine Klasse, die den allgemeinen Fall beschreibt, von dem dann mittels Vererbung Unterklassen
gebildet werden können.
Object
eine Klasse, die allgemeine Objekteigenschaften enthält und als Oberklasse für alle Klassen
dient.
Objekt
ein Exemplar, das Eigenschaften hat und Aktionen durchführen kann. In der objektorientierten
Programmierung werden Objekte mit Programmen beschrieben, die Klassen genannt werden.
Objektorientierte Analyse (OOA)
die Überlegung, aus welchen Objekten und Klassen eine Aufgabenstellung besteht, und welche
Eigenschaften und Aktionen diese Objekte haben, vorerst noch unabhängig von der verwendeten
Programmiersprache.
Objektorientiertes Design (OOD)
das Konzept, wie das Ergebnis der objektorientieretn Analyse am besten in einer bestimmten
Programmiersprache realisiert werden kann.
Objektorientierte Programmierung (OOP)
das Schreiben von Programmen, in denen die Eigenschaften und Aktionen von Objekten bzw.
von Klassen von Objekten festgelegt werden, in einer Programmiersprache.
Open Database Connectivity (ODBC)
eine Schnittstelle für den Zugriff auf Datenbanken von Programmen aus.
OutputStream
Html, JavaScript und Java
- 60 -
15. Februar 2005 / 17:55:59
die Oberklasse für alle Klassen für die Byte-orientierte Ausgabe.
Paket (package)
eine Menge von zusammengehörenden Klassen.
Polymorphismus
siehe Überschreiben.
Portnummer
eine Nummer, die eindeutig angibt, an welches Programm innerhalb eines Rechners (siehe
Hostname) eine Information übertragen werden soll.
println
eine Methode für die Ausgabe einer Textzeile, von den englischen Wörtern für drucken und
Zeile.
private
kann nur innerhalb derselben Klasse angesprochen werden, vom englischen Wort für privat.
Programm
eine Anweisung an einen Computer, welche Aktionen er wann ausführen soll. In der
objektorientierten Programmierung werden Programme meist Klassen genannt.
Programmiersprache
eine für Menschen lesbare und für Computer mit Hilfe eines Compilers verständliche Sprache,
mit der ein Mensch in Form eines Programms festlegen kann, welche Aktionen ein Computer
ausführen soll.
protected
kann von allen Klassen aus angesprochen werden, die im selben Paket liegen oder eine
Unterklasse dieser Klasse sind, vom englischen Wort für geschützt.
Protokoll
eine Festlegung, wie die Übertragung von Informationen zwischen zwei Programmen oder
Systemen erfolgen soll.
public
kann von allen Klassen aus angesprochen werden, vom englischen Wort für öffentlich.
Reader
die Oberklasse für alle Klassen für die textorientierte Eingabe.
Referenz
eine Angabe, wo ein bestimmtes Datenfeld zu finden ist; in manchen Programmiersprachen auch
als Pointer (Zeiger) bezeichnet. In Java werden Objekte und Felder (arrays) immer über
Referenzen angesprochen.
Relationale Datenbank
eine Datenbank, bei der die Informationen in Form von Relationen gespeichert sind, d.h. in Form
von Tabellen und von Beziehungen zwischen Tabellen.
Runnable
ein Interface für Programme, die als selbständige Threads ablaufen können.
Serializable
ein Interface für Objekte, die als Folge von Bytes gespeichert oder übertragen werden können.
Servlet
ein Java-Programm, das innerhalb eines Web-Servers abläuft und die Ausgabe an einen
Web-Browser sendet.
Server
ein Computer oder Programm, das die Informationen oder Dienste anbietet, die von einem Client
nachgefragt werden. Der Name kommt vom englischen Wort für einen Kunden bedienen.
sleep
eine Methode für eine Zeitdauer, in der ein Programm keine Aktivität ausführt, vom englischen
Wort für schlafen.
Signatur (Signature)
Kennzeichen, Unterschrift; bei Methoden: das, was die Methode eindeutig kennzeichnet, nämlich
Name und Parameterliste.
Socket
eine Verbindung zwischen einem Programm auf einem Computer über das Internet oder Intranet
zu einem anderen Programm auf einem anderen Computer. Der Name kommt vom englischen
Wort für Steckdose.
Source-Programm (Quellprogramm)
das von Menschen geschriebene Programm, das dann vom Compiler in das am Computer
ausführbare Binärprogramm übersetzt wird.
static
eine Eigenschaft oder Methode, die nicht je einmal pro Objekt, sondern von Anfang an nur
Html, JavaScript und Java
- 61 -
15. Februar 2005 / 17:55:59
einmal für die Klasse existiert.
Statement (Anweisung)
ein einzelner Schritt, der innerhalb eines Programms ausgeführt wird.
String
eine Klasse für Zeichenketten, also für Texte oder Teile von Texten.
Structured Query Language (SQL)
eine Sprache für die Datenabfrage und Datenänderung in Datenbanken.
Syntax (Grammatik)
die Regeln, wie die Wörter, Zahlen und Sonderzeichen in einem Source-Programm geschrieben
werden müssen, damit es vom Compiler richtig verstanden und richtig übersetzt werden kann.
System
eine Klasse für Systemkomponenten und Systemfunktionen.
Sun Microsystems
die EDV-Firma, in der die Programmiersprache Java entwickelt wurde.
Swing
ein umfangreiches Paket von Java-Klassen für Graphische User-Interfaces, bei denen das
Aussehen komplett innerhalb des Java-Programms festgelegt wird. Dies wird auch als
leichtgewichtige Klassen bezeichnet (englisch light-weight). Der Produktname Swing kommt
vom englischen Wort für Schaukel und für schwungvolle Musik.
TCP/IP
das Protokoll, nach dem die Übertragung im Internet und in Intranets erfolgt, eine Abkürzung für
Transaction Control Protocol / Internet Protocol.
Thread
ein Programmteil, der zeitlich unabhängig von anderen Programmteilen abläuft, und eine Klasse,
mit der solche Abläufe gesteuert werden können; vom englischen Wort für Faden.
Timeout
eine maximale Wartezeit, vom englischen Wort für Zeitüberschreitung.
toString
die Methode, die Objekte durch einen für Menschen lesbaren Text darstellt.
Überladen
die Definition von mehreren Methoden oder Konstruktoren, die den gleichen Namen, aber
verschiedene Parameterlisten haben und deshalb als verschiedene Methoden gelten.
Überschreiben
die Definition einer Methode in einer Unterklasse, die für Objekte dieses Typs die von der
Oberklasse geerbte Methode ersetzt. Dies wird auch als Polymorphismus bezeichnet, vom
griechischen Wort für viele Gestalten.
Unicode
ein Zeichensatz, der alle Schriftzeichen der Menschheit umfasst (nicht nur die westeuropäischen).
Uniform Resource Locator (URL)
eine Adresse, unter der eine Information oder Datei über das Internet erreichbar ist; außerdem
eine Klasse für den Zugriff auf solche Informationen. Der Name bedeutet eine einheitliche
Ortsangabe für Ressourcen.
Unterklasse (Subklasse)
eine Klasse, die einen Spezialfall einer Oberklasse beschreibt und alle Eigenschaften und
Methoden von der Oberklasse erbt (Vererbung).
Utility
ein Hilfsprogramm, vom englischen Wort für nützlich.
Vererbung
eine Beziehung der Art "Unterklasse ist ein Spezialfall von Oberklasse".
Web-Browser
ein Computer bzw. das dort laufende Client-Programm, mit dem der Benutzer auf Web-Pages
und eventuell auch auf andere Internet-Dienste zugreifen kann.
Web-Page
eine über das WWW auf einem Web-Server angebotene Information, meist in Form eines
HTML-Files.
Web-Server
ein Computer bzw. das dort laufende Server-Programm, das Web-Pages über das WWW
anbietet.
World-Wide Web (WWW)
ein Informationssystem, das einen weltweiten Zugriff auf Informationen bietet, die meist in der
Form von HTML-Files (Web-Pages) angeboten werden. Der Zugriff erfolgt nach dem Prinzip
von Server und Client über das Internet mit dem Protokoll HTTP. Der Name bedeutet so viel wie
Html, JavaScript und Java
- 62 -
15. Februar 2005 / 17:55:59
weltweites Spinnennetz oder weltweites Gewebe. (siehe auch WWW Was ist das).
Writer
die Oberklasse für alle Klassen für die textorientierte Ausgabe.
Html, JavaScript und Java
- 63 -
15. Februar 2005 / 17:55:59
VII Beispiel-Programme (Java applications)
Prog
Name
Beschreibung
1
Helloworld
Hello world!; einfachstes Programm
2
Deklarationen
Variablendeklarationen in javaScript#
3
Welcome2
andere reihenfolge der befehle
4
Beispiel4
mit FOR-Schleife
5
Bonbon
if/else/boolean
6
Umwandel1
double in int Wert wandeln
7
Umwandel2
"
8
Umwandel2
mit Zeilennummern
9
Fehler1
verschiedene Fehler eingebaut
10
Fehler2
verschiedene Fehler eingebaut
11
PQFormel1
funktionsfähig; mit math pow
12
PQFormel2
funktionsfähig; mit if Abfrage
13
HelloText
Textstring über Variable ausgeben
14
PQFormel3
PQFormel mit if-Abfrage +switch/case (Pohl)
15
PQFormel4
wie 14 mit i/o von der Tastatur
16
HelloPerson
arbeiten mit Prozeduren und strings
17a
GrundGeruestAWT leeres Fenster für GUI-Anwendungen (Grundgerüst)
17b
GrafikBeispiel
GrafikBeispiel mit Fehlern
17c
ErsterRahmen
GrafikBeispiel (leeres Fenster) (schließt nicht)
17c
Zweites Beispiel
GrafikBeispiel (leeres Fenster)
18
Telefon
TelefonBeispiel; Button, Label auf Panel
19
GrafikBeispiel
GrafikBeispiel mit WindowClosingAdapter
20
SimplePanel
Wiedergabe von Text im Panel
21
TextAusgabe
Textausgabe (Font/Größe) auf Panel mit WindowClosing
22
ButtenPanel
4 anklickbare Button auf Panel (2 Versionen)
23a
Kreise
verschiedene Kreise (Schleife) auf Canvas
23b
LinieRecht
verschiedene Linien und rechtecke in Schleifen
23c
Polygone
verschiedene gefüllte/leere Polygone auf Canvas
24
datei1
25a
BildBeispiel
Laden eines Bildes mit WindowClosingAdapter
25b
Bildladen
Laden eines Bildes ohne Anpassung mit windowclosing
25c
Bildsignierer
Fenster und canvas mit Datei Pulldown-Menu
25d
Bild
Laden eines Bildes nach Steyer
25e
Bilder
mehrere Bilder laden nach Steyer
26
Fakultaet
Berechnung der Fakultät (noch nicht fertig)
27
newton
Newton Verfahren zur Berechnung der Nullstelle einer Funktion
28
PlaySound
Application: Soundwiedergabe mit newAudioClip (class Applet)
28 Minimal PlaySound
"
Application: Minimalversion mit File im Quelltext (s. Vers1)
28 Vers1
PlaySound
Application: Soundwiedergabe mit File im Quelltext
28 Vers2
PlaySound
Mit newAudioClip +langem,getrennten Filenamen im Quelltext
28 Vers3
PlaySound
Mit newAudioClip + Eingabe filenamen auf DOS in args[0]
Html, JavaScript und Java
- 64 -
15. Februar 2005 / 17:56:00
28 Vers4
PlaySound
Mit newAudioClip aber verkürztem Filenamen
28 Vers5
AudioClipDemo
Mit DOS-Eingabe Filename+Fehlerroutinen
29
CMitarbeiterBeispiel Klassenbildung: Mitarbeiter
30
31
32
33
40 EinComp Client/-ServerSocket Client/Server-SocketDemo: Netzprogrammierung Ein_Rechner
40 LAN
Html, JavaScript und Java
ClientServerSocket
Client/Server-SocketDemo: Netzprogrammierung im LAN
- 65 -
15. Februar 2005 / 17:56:00
VIII Beispiel-Programme (Java-Applets)
Prog
Name
Inhalt
1
HelloWorldApplet
Simples Applet zur Ausgabe eines einfachen Textes „Hallo“
2
Automatik
Bspl. zum Aufruf der Methoden init,start,stop,destroy
3
LebensZyklusBspl
Init,start,stop,destroy als Lebenszyklus
AppletInfo
Etwas komplexeres mit Informationen über das Applet mit
getAppletInfo()
5
AppletMitParameter
Verwendung einer Parameterübergabe von Html an das Applet
6
AppletMitParametern
Wie Nr. 5 aber mit mehreren Parametern
AppletEventhandling
ActionListener mit 1 Button und Textausgabe (1Satz) im Applet
(Minimalprog.)
8
AppletSoundMinimal
Soundausgabe von Hello/World (1 Melodie)
9
AppletSound
Ausgabe 2 Melodien über 2 Buttons
AppletSound
(Version1)
Mehrere Musikstücke mit Auswahlmenü und play und stop
10
10
AppletSound
(Version2)
Mehrere Musikstücke mit Auswahlmenü und play und stop;
(Knöpfe anders angeprdnet)
AppletSound
(Version3)
Mehrere Musikstücke mit Auswahlmenü und play und stop;
4
7
10
11
(Knöpfe anders angeprdnet)
AppletEventHandlingT Einlesen und Ausgabe eines längeren Textes über File
ext
12
13
Html, JavaScript und Java
- 66 -
15. Februar 2005 / 17:56:00
IX Referenzen
Online-Informationen über JavaScript:
http://www.jakober.ch/js/js_intro.php
http://rhea.tci.uni-hannover.de/selfhtml/tea.htm
http://www.inf.fu-berlin.de/inst/ag-bg/lv/pi/www/javascript.html
Online-Informationen über Java:
Online-Dokumentation (API) des JDK [Seite 8] - auch on-line auf http://java.sun.com/docs/
http://java.sun.com/ - auch unter http://www.javasoft.com/
http://www.gamelan.com/
http://www.sourceforge.net/
http://codeguru.developer.com/java/
Java Tutorial auf http://java.sun.com/docs/books/tutorial/index.html
Java FAQ auf http://sunsite.unc.edu/javafaq/javafaq.html
Java Programmers FAQ auf http://www.afu.com/javafaq.html
Java Glossary in http://mindprod.com/gloss.html
deutsche Java-FAQ auf http://www.dclj.de/
Bücher:
Java-Einführung von Hubert Partl auf http://www.boku.ac.at/javaeinf/
Go to Java 2 von Guido Krüger auf http://www.gkrueger.com/
Java ist auch eine Insel von Christian Ullenboom auf http://java-tutor.com/
Java Dokumentation von Brit Schröter und Johann Plank auf http://www.selfjava.de/
Thinking in Java von Bruce Eckel auf http://www.BruceEckel.com/javabook.html
siehe auch http://www.yahoo.com/ (Suche)
Online-Informationen über Internet, WWW und HTML:
HTML-Einführung von H.Partl - auch online auf http://www.boku.ac.at/htmleinf/
W3-Consortium - auf http://www.w3.org/
siehe auch http://www.yahoo.com/ (Suche)
Newsgruppen über Java und Web-Pages:
comp.lang.java.help
comp.lang.java.programmer
comp.lang.java.gui
und andere Spezialgruppen in der Hierarchie comp.lang.java.*
comp.infosystems.www.authoring.html.misc
comp.infosystems.www.authoring.site-design
und andere Gruppen in der Hierarchie comp.infosystems.*
de.comp.lang.java
de.comm.infosystems.www.authoring.misc
und andere Gruppen in den Hierarchien de.comm.* und de.comp.*
siehe auch http://groups.google.com/ (ehemals DejaNews) (Suche)
Html, JavaScript und Java
- 67 -
15. Februar 2005 / 17:56:00