Einführungspraktikum Java - duepublico.uni-duisburg-essen.de · ♦ Java 1 und JDK 1.0.2: Wird von allen Java-fähigen Web-Browsern und Plattformen unterstützt, aus praktischer

Begleitmaterial zum

Einführungspraktikum Java

- November 2001 -

Universität Essen Schützenbahn 70

45127 Essen

Dozent: Dipl.-Wirt. Inform. Frank Lützenkirchen [email protected]

mailto:[email protected]

2

HRZ Einführungspraktikum Java 2

3

Themenübersicht

I. Einführung und erste Schritte mit Java - Entstehung von Java, Java heute, Eigenschaften von Java - Realisierung der Plattformunabhängigkeit mit der Java Virtual Machine - Verwendung des JDK, Applets und Applikationen - Literatur, Software und Informationsquellen im Internet II. Grundlegende Sprachelemente - Kommentare und Anweisungen, Variablen, Datentypen und Literale - Operatoren, Arrays, Fallunterscheidungen und Schleifen - Methoden schreiben, Arbeiten mit Zeichen und Zeichenketten III . Objektorientierte Programmierung mit Java - Klassen, Objekte, ihre Verwendung und ihr Lebenszyklus - Klassen und Konstruktoren, Zugriffsschutz durch Modifier - Klassen- und Instanzvariablen, Klassen- und Instanzmethoden - Polymorphismus und Overloading, Vererbung und Overriding - Abstrakte Klassen, Interfaces und Packages nutzen IV. Nützliches und Wissenswertes - Die Klasse Objekt und Wrapper-Klassen, Casting und Konvertierung von Datentypen - Datums- und Zeitwerte, Mathematische und Zufallsfunktionen - Laufzeitfehler erzeugen und abfangen mit Exceptions - Aus der Werkzeugsammlung: StringTokenizer, Vector, Stack und Hashtable - Die Klassen System, Runtime und Process V. Applets, Grafik- und Soundausgabe, Ereignisse - Applets schreiben und einsetzen, Appletmethoden - Zeichnen mit der Klasse Graphics, Bilder, Farben und Zeichensätze einsetzen - AudioClips abspielen und MediaTracker einsetzen - Das Delegation Event Modell am Beispiel von Maus- und Tastaturereignissen VI. Graphische Benutzeroberflächen mit dem AWT - Das Abstract Windowing Toolkit und seine Funktionsweise - Bausteine graphischer Oberflächen: Container, Komponenten und Layout-Manager - Fenster und Menüs VII. Ein- und Ausgabe, Netze, Dateien und Fortgeschrittenes - Arbeiten mit Ein- und Ausgabeströmen, Zugriff auf Dateien und Verzeichnisse - Netzwerkfunktionalität von Java - Einblicke in fortgeschrittene Techniken:

Datenbankzugriffe mit JDBC, Grafische Oberflächen mit Swing, Java Servlets


4


5

I. Einführung und erste Schritte mit Java


I. Einführung und erste Schritte mit Java 6

1. Entstehung von Java

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

1991 Gründung des "Green Project" bei Sun Microsystem: Schaffung einer einfachen, objektorientierten Programmiersprache für Steuerungselektronik im Consumerbereich. Plattformunabhängigkeit und Stabilität spielen eine große Rolle. Das Resultat heißt "Oak". Sun gründet 1992 First Person, Inc. zur Vermarktung. Es entsteht ein tragbares Gerät mit dem Namen "*7" (Star seven), das über einen animierten "Assistenten" mit dem Namen "Duke" verfügt und eine Art Universalfernbedienung für Haushaltselektronik realisiert. Viele Verhandlungen, z. B. im Bereich Set-Top-Boxen, scheitern. Oak findet noch keinen Markt. Im Frühjahr 1994 wird First Person, Inc. aufgelöst. Im Juni 1993 wird die erste brauchbare Version eines Browsers für das World Wide Web mit dem Namen Mosaic bekannt. Das WWW verbreitet sich von nun an rasant. Ende 1994 kommt bei Sun die Idee auf, Oak als freie Programmiersprache für das World Wide Web umzuarbeiten. Ein einfacher Browser namens "WebRunner" kann im Herbst 1994 bereits kleine Oak-Applets ausführen. Anfang 1995 wird der Name "Java" gewählt, nach einer im Silicon Valley auch unter den Sun-Programmierern beliebte starke Bohnenkaffee-Sorte. Es wird viel Arbeit in die Bereiche Netzwerkfähigkeit und Sicherheit von Java gesteckt: Aus Oak wurde Java. Im März 1995 entdeckt Netscape-Gründer Marc Andreessen das Java-Projekt. Im Dezember 1995 ist die Netscape-Version 2.0 mit integrierter Java-Unterstützung verfügbar. Java Applets werden als erste Möglichkeit zur Realisierung dynamischer Web-Seiten schnell populär. Im Frühjahr 1996 ist die erste Beta-Version des Java Development Kit (JDK) 1.0 im Internet frei erhältlich. Die kostenlose Java-Entwicklungsumgebung trägt erheblich zur schnellen Verbreitung der Programmiersprache bei.

2. Java heute

Inzwischen ist Java als ernstzunehmende objektorientierte Programmiersprache etabliert und für nahezu alle gängigen Plattformen in aktuellen Versionen verfügbar. Auf der Client-Seite (Java Applets) hat Java in letzter Zeit deutlich an Bedeutung verloren. Wesentlicher Grund hierfür ist die mangelnde Browser-Unterstützung im Netscape Navigator und Internet-Explorer, die beide die aktuellsten Java-Versionen nur mit einem separat zu installierenden Java Plug-in von Sun unterstützen. Auf der Server-Seite hat sich Java deutlich stärker etabliert. Java Servlets und Java Server Pages lösen CGI-Anwendungen ab. Mächtige Klassenbibliotheken unterstützen aktuelle Standards, insbesondere Datenbankzugriffe mit JDBC, XML, LDAP, IMAP / POP3. Mit der Java 2 Micro Edition kehrt Java zu den ursprünglichen Anwendungsgebieten von Oak zurück. Es gibt Java-Umgebungen für Palm-Handhelds und ein erstes Java-fähiges Handy von Motorola. Java verbreitet sich ebenfalls stark als System zur Programmierung von Chip-Karten (JavaCard).



3. Die Plattformunabhängigkeit von Java

Java-Quellcode besteht aus Dateien mit der Endung "*.java". Dieser Quellcode wird durch einen Compiler übersetzt.

♦

♦

♦

♦

♦

♦

Es entsteht kein ausführbares Programm, sondern Java Bytecode mit der Endung "*.class". Der Bytecode stellt eine plattformunabhängige, vorkompilierte Form des Java-Codes dar. Er besteht aus einfachen, mit Maschinensprache vergleichbaren Anweisungen für einen virtuellen Computer, der Java Virtual Machine. Die Funktionsweise der Java Virtual Machine und der Bytecode-Anweisungen, die sie zu verarbeiten hat, ist genau definiert. Anbieter, die ihr System Java-fähig machen wollen, müssen eine entsprechende Virtual Machine für die jeweilige Plattform implementieren. Java Bytecode wird durch die Java Virtual Machine ausgeführt. Diese kann als eigenständiges Programm ausgelegt sein (z. B. java im JDK), Bestandteil eines Web-Browsers sein (z. B. integriert im Netscape Navigator) oder in Zukunft als Hardware in Form eines Prozessors z. B. in einer Waschmaschine existieren. Die Virtual Machine ist nicht nur ein virtueller Prozessor, sondern bietet auch eine virtuelle Betriebssystem-Umgebung nach, z. B. um Zugriffe auf Dateien und Verzeichnisse, das Fenstersystem der Plattform oder das Netzwerk zu ermöglichen. Die Virtual Machine kontrolliert die Zugriffe auf diese Ressourcen, was differenzierte Sicherheitsmechanismen ermöglicht. Der Sprachumfang des Java Bytecodes ist sehr gering. Er wird ergänzt durch eine Sammlung von Java-Klassenbibliotheken (Standard-Packages), die wiederum größtenteils in Java geschrieben sind und auf dem jeweiligen Laufzeitsystem der Virtual Machine vorausgesetzt werden können.

Java-Quellcode *.java

Compiler

Java-Bytecode *.class

Java- enabled Web-Browser ( Netscape, IE )

Java Virtual

Machine

Java Virtual

Machine

Java Runtime Environment (java)



4. Wichtige Eigenschaften von Java ♦ Java ist streng genommen eine interpretierte Sprache. Übersetzte Java-Programme

werden von einem Interpreter, der Java Virtual Machine, ausgeführt. Neuere JVMs verbessern allerdings inzwischen mit integriertem Just-in-Time-Compiler und dem Hot-Spot-Konzept die Performance gegenüber reinen Java-Interpretern erheblich.

♦ Java ist plattformunabhängig. Java-Anwendungen, die in 100 % reinem Java geschrieben sind, laufen ohne jegliche Veränderung auf allen Systemen, für die eine Java-Laufzeitumgebung zur Verfügung steht.

♦ Java ist durchgehend objektorientiert. Java-Code besteht aus Klassen, in denen Variablen und Methoden definiert sind. Objektorientierte Konzepte wie Vererbung, Overloading und Overriding werden unterstützt.

♦ Java ist relativ einfach zu erlernen. Java lehnt sich stark an C++ an, besitzt jedoch keine Zeiger und keine Mehrfachvererbung. Java ist recht übersichtlich strukturiert und hat eine einfache Syntax, daher weniger schwerverständlicher Code als z.B. in Perl oder C. Da Java neu entworfen wurde, gibt es weniger Altlasten als z. B.in C++.

♦ Java arbeitet in einer virtuellen Betriebssystemumgebung. Plattformunabhängige Java-Anwendungen laufen in einer plattformabhängigen Java Virtual Machine, die die Aufrufe des Java-Programms auf Aufrufe des jeweiligen Systems abbildet, z .B. den Zugriff auf Dateien.

♦ Java bietet integrierte Sicherheitsmechanismen. Die Java Virtual Machine überwacht zur Laufzeit den Zugriff auf das System und verhindert z. B., daß aus dem Netz geladene Java-Applets lokale Daten lesen können.

♦ Java ist robust. Laufzeitfehler können hierarchisch auf verschiedenen Ebenen vom Programmierer abgefangen, weitergeleitet oder selbst erzeugt werden.

♦ Java ist streng typisiert. Die Verwendung der Datentypen wird zur Übersetzungszeit genau überprüft. Der Wertebereich von Datentypen ist plattformübergreifend einheitlich definiert.

♦ Java ist multithreadingfähig. Java bietet Konstrukte, um in einer Anwendung verschiedene Teile parallel ausführen zu können.

♦ Java besitzt keine Mechanismen, um direkt auf Hardware, z. B. eine bestimmte Speicheradresse, zuzugreifen.

♦ Java verwaltet eigenständig den Arbeitsspeicher. Eine Garbage Collection wird von Java regelmäßig automatisch angestoßen, um den Speicher von nicht mehr benutzten Objekten zu säubern. Der Programmierer muß seine Objekte nicht mehr explizit freigeben.

♦ Java bietet eine integrierte Netzwerkunterstützung mit Klassen für Datenströme, URLs, Sockets etc zur Kommunikation auf der Basis der TCP/IP und UDP-Protokollfamilie.

♦ Java-Anwendungen sind klein. Das Java-Laufzeitsystem belegt nur einige hundert KByte. Da die Java-Bibliotheken auf dem Client vorausgesetzt werden können, müssen sie nicht zum übersetzten Programm dazugebunden werden. Die übertragene Datenmenge für ein einfaches Java-Applet ist daher vergleichsweise gering.

♦ Das Java 2 Software Development Kit und inzwischen auch integrierte graphische Entwicklungsumgebungen sind frei verfügbar, jedoch liegen das Copyright und alle Rechte an Java bei Sun Microsystems. Java ist also kein offener Standard, sondern ein herstellerabhängiges Produkt!



5. Literatur und Software zu Java 5.1 Empfehlenswerte Literatur für Einsteiger

♦ Guido Krüger: Go To Java 2,

Handbuch der Java-Programmierung Addison-Wesley, ISBN: 382731710X, DM 99,90 Gebundene Ausgabe - 1207 Seiten

♦ Bruce Eckel: Thinking in Java,

Prentice Hall; ISBN: 0130273635, ca. DM 100,-, Taschenbuch kartoniert - 1128 Seiten

5.2 Literatur online und zum Download als HTML oder PDF ♦ Sun: The Java Tutorial - A practical guide for programmers:

http://www.javasoft.com/docs/books/tutorial/ ♦ Gosling, James; Joy, Bill; Stelle, Guy: The Java Language Specification

http://www.javasoft.com/docs/books/jls/index.html ♦ Eckel, Bruce: Thinking in Java:

http://www.bruceeckel.com/ ♦ Krüger, Guido: Go To Java 2:

http://www.javabuch.de/ 5.3 Java-Entwicklungsumgebungen ♦ http://www.javasoft.com/j2se/

Das Java 2 Software Development Kit, Standard Edition, Version 1.3Kommandozeilen-Umgebung zum Compilieren und Ausführen von Java-und wird von Sun zum freien Download für Windows, Linux und Solaris

♦ http://www.jcreator.com/ JCreator ist eine graphische Entwicklungsumgebung (IDE) für Java, von kostenlose Freeware-Version (JCreator LE 2.0) gibt. Der Funktionsumfansich auf das Wesentliche, dafür ist das Programm aber auch schneller als JBuilder.

♦ http://www.borland.com/jbuilder/personal/ Die graphische Java-Entwicklungsumgebung Borland JBuilder 5.0 stehtEdition für Windows, Solaris und Linux frei zur Verfügung.

♦ http://www.sun.com/forte/ffj/ Die Java-IDE Forte for Java 3.0 ist eine weitere Alternative, die direkt vangeboten wird. Die freie Version heisst hier Community Edition und sfür Windows, Solaris, Linux und als reine Java-Implementierung zur Verf

HRZ Einführungspraktikum Java

:

.1 ist eine reine Anwendungen angeboten.

der es auch eine g beschränkt Forte und

in der Personal

on Sun teht ebensfalls ügung.

9

http://java.sun.com/docs/books/tutorial/

http://java.sun.com/docs/books/jls/index.html

http://www.mindview.net/javabook.html

http://www.addison-wesley.de/Service/Krueger/httoc.htm

http://www.javasoft.com/

http://www.jcreator.com/

http://www.borland.de/jbuilder/index.html

http://www.borland.de/jbuilder/index.html


6. Das Java 2 SDK und Java-Versionen 6.1 JDK (Java Development Kit) bzw. SDK (Software Development Kit) ♦ Frei verfügbares Entwicklungssystem für Java, beinhaltet den Java-Compiler javac, den

Java-Interpreter java zum Ausführen von Java-Applikationen, den appletviewer zum Ausführen von Java-Applets und weitere Tools

♦ Beinhaltet die Standard-Klassenbibliothek von Java inkl. Dokumentation und Quellcode ♦ Keine graphische Entwickler-Oberfläche, nur Kommandozeilen-Tools ♦ Windows-, Solaris- und Linux-Versionen werden von Sun entwickelt, weitere Versionen

durch Drittanbieter portiert, z. B. von Apple für Mac, von IBM für AIX usw. ♦ Funktion eines Referenzsystems für den aktuellen Sprachumfang 6.2 Java-Versionen und Editionen ♦ Der aktuelle Sprachumfang von Java wird durch die Versionen des Java Development

Kit (JDK/SDK) festgelegt. Die dritte Stelle der Versionsnummern dokumentiert den Stand von Bugfixes etc., aber keine Erweiterungen des Standard-Sprachumfangs:

♦ Java 1 und JDK 1.0.2: Wird von allen Java-fähigen Web-Browsern und Plattformen unterstützt, aus praktischer Sicht derzeit oft noch die wichtigste Java-Version für die Entwicklung von Java-Applets, die auf möglichst allen Browsern laufen sollen.

♦ Java 1.1 und JDK 1.1.8: Wird in vollem Umfang nur von den neuesten Browsern unterstützt, z .B. Netscape Communicator 4.7. Wesentliche Verbesserungen in Funktionalität (z. B. JDBC), Geschwindigkeit und Stabilität.

♦ Umbenennung des JDK nach der Version 1.1.8 in "Java 2 Software Development Kit" (Java 2 SDK). Der aktuelle Sprachumfang wird auf der Browser-Seite leider kaum unterstützt, auf der Server-Seite sind aktuelle Java-Versionen verfügbar. Netscape 6 ist derzeit der einzige Browser, der von der Installation an eine Java 2 Umgebung bieten kann. Andere Browser erfordern die separate Installation des Java Plug-in und spezielle HTML-Seiten zum Starten eines Applets mit diesem Plug-in.

♦ Aktuellste Versionen: Java 2 SDK 1.2.2 und 1.3.1. Version 1.4 befindet sich derzeit im Beta-Stadium.

♦ Alle aktuellen Java-Entwicklungsumgebungen und Standard-Bibliotheken sind Teil der "Java 2 Platform". In dieser werden nun verschiedene Editionen unterschieden:

♦ Java 2 Standard Edition:

Entwicklung von Applets und Applikationen für Desktop-Clients / PC Gegenstand dieses Kurses

♦ Java 2 Enterprise Edition: Erweiterung der Standard Edition um zusätzliche Bibliotheken und standardisierte Schnittstellen, z. B. XML, Servlets/JSP, EMail, Verzeichnisdienste, Enterprise Java Beans Einsatz in Application Servern

♦ Java 2 Micro Edition: Eingeschränkter Sprachumfang, spezielle Entwicklungsumgebungen Spezialisierung auf Kleingeräte wie PDAs (Palm), Handys etc.



7. Erste Schritte mit dem JDK bzw. SDK ♦ Welche Java-Version ist installiert? java –version ♦ Wie compiliert man eine Quellcode-Datei? javac HelloWorld.java Es entsteht eine Datei HelloWorld.class. ♦ Wie führt man eine Java Application aus? java HelloWorld ♦ Wie führt man ein Java Applet aus? ... durch Laden der HTML-Seite im Browser, die das Java Applet einbindet und aufruft! ♦ Die Umgebungsvariable CLASSPATH enthält eine Liste von Verzeichnissen, in denen die

Java Laufzeitumgebung nach Class-Dateien sucht. Werden class-Dateien nicht gefunden, überprüfen Sie diese Variable und erweitern Sie sie gegebenenfalls, z. B. für Unix

export CLASSPATH=.:~hrz120/myprojects/classes:$CLASSPATH ♦ Zusammengehörende Java-Class-Dateien einer Klassenbibliothek sind oft in einer Jar-

Datei (Java Archive) zusammengefasst. Java Laufzeitumgebungen können Jar- und Zip-Dateien wie Verzeichnisse nach Class-Dateien durchsuchen. Jar- und Zip-Dateien werden wie Verzeichnisse im CLASSPATH eingetragen:

export CLASSPATH=$CLASSPATH:/x/y/swingall.jar:/x/y/other.jar ♦ Jar-Dateien können mit dem Kommandozeilen-Tool jar bearbeitet werden, dessen

Aufrufsyntax vom tar-Kommando übernommen ist: jar –vtf demo.jar zeigt den Inhalt einer Jar-Datei jar –xvf demo.jar packt den Inhalt einer Jar-Datei aus. jar –cvf demo.jar * erzeugt eine Jar-Datei mit allen Class-Dateien aus dem aktuellen Verzeichnis.



8. Applets und Applications ♦ Java-Programme können in zwei verschiedenen Formen auftreten:

♦ Applications sind Java-Anwendungen, die wie gewöhnliche Anwendungen (d. h. ohne einen WWW-Browser) gestartet werden. Dazu benötigt man ein Java-Laufzeitsystem, das die Java-Applikation dann ausführt.

♦ Applets sind Java-Anwendungen, die in eine HTML-Seite eingebunden sind und mit dieser aus dem WWW heruntergeladen werden. Java-fähige Webbrowser führen dann das Applet aus und stellen es als Teil der WWW-Seite dar, sobald alle Bestandteile heruntergeladen wurden.

♦ Java Beans und Java Servlets sind weitere Erscheinungsformen von Java-Anwendungen. 8.1 Eine einfache Java-Application: HelloWorld.java public class HelloWorld { public static void main( String[] args ) { System.out.println( "Hello World!" ); } }

Beachte: ♦ Java ist durchgehend objektorientiert, d. h. in Java gibt es auf der obersten Ebene nur

Klassen. Auch eine Java-Anwendung besteht also mindestens aus einer Klasse. Mehr zu Klassen und Objektorientierung später.

♦ Der Dateiname muß exakt mit dem Klassennamen übereinstimmen (Hier also "HelloWorld.java" ).

♦ Jede (public-) Java-Klasse muß in einer eigenen Datei angegeben werden. ♦ Java-Applikationen müssen eine Methode main besitzen, die automatisch vom

Laufzeitsystem aufgerufen wird, wenn man ihm diese Java-Klasse zur Ausführung übergibt. Mehr zu Methoden später.

♦ Die Methode main muß public und static deklariert sein ♦ String[] args ist ein Feld (Array) aus Zeichenketten, das eventuell mit dem Aufruf

übergebenen Parameter aus der Kommandozeile aufnimmt. ♦ System.out ist ein Objekt, das den Standard-Ausgabestrom des Systems darstellt (also

z. B. den Bildschirm oder die Java Console im Netscape Navigator) ♦ System.out besitzt eine Methode println, mit der man Zeichenketten auf dem

Bildschirm ausgeben kann. Hier wird also die Zeichenkette "Hello World!" ausgegeben.

♦ Groß- und Kleinschreibung werden in Java genauestens unterschieden! ♦ Leerzeichen, Tabulatoren, Leerzeilen usw. werden von Java wie einfache Leerzeichen

behandelt und können zur Strukturierung des Codes verwendet werden.



8.2 Ein einfaches Java-Applet: HelloWorldApplet.java import java.applet.Applet; import java.awt.Graphics; public class HelloWorldApplet extends Applet { public void paint( Graphics g ) { g.drawString( "Hello World!", 20, 25 ); } } Hinweise: ♦ Der Dateiname dieses Quellcodes muß "HelloWorldApplet.java" lauten ♦ Mit der Anweisung import werden dem Java-System Sprachbestandteile

bekanntgemacht, die nicht standardmäßig geladen sind. Hier werden die Klassen Applet und Graphics aus den Paketen java.applet und java.awt geladen. Standardmäßig sind nur die Klassen aus dem Paket java.lang bekannt. Mehr zu Packages später!

♦ extends Applet teilt Java mit, daß diese Klasse von der Klasse Applet abgeleitet ist, daß es sich also um ein Applet handelt. Mehr zu Vererbung später!

♦ Wenn Java-Applets, die in eine Webseite eingebunden wurden, geladen sind, ruft der Browser automatisch die Methode paint auf, um den Bereich des Applets auf dieser Seite zu "bemalen".

♦ Das System übergibt der Methode paint ein Objekt vom Typ Graphics, das die "Malfläche" repräsentiert.

♦ Das Objekt Graphics besitzt eine Methode drawString, um an den angegebenen Koordinaten eine Zeichenkette auszugeben.



8.3 Aufruf eines Applets ♦ Java-Applets werden in eine HTML-Seite eingebunden und dann automatisch als Teil der

Seite durch einen Java-fähigen Browser gestartet und angezeigt: Datei applet.html: <HTML> <HEAD> <TITLE> Ein einfaches Beispiel </TITLE> </HEAD> <BODY> <H1> Auf dieser Seite sehen Sie das Applet HelloWorld </H1> Etwas Text.<P> <APPLET CODE = "HelloWorldApplet.class" WIDTH = 100 HEIGHT = 50 > </APPLET> Noch etwas Text.<P> </BODY> </HTML> Beachte: ♦ Der Name der HTML-Seite ist unabhängig vom Namen des Applets. ♦ Eine HTML-Seite kann mehrere Applets gleichzeitig beinhalten. ♦ Das Applet wird durch das HTML-Tag <APPLET> aufgerufen und erscheint dann an

dieser Stelle auf der Seite. Mehr dazu später! ♦ Die CODE-Anweisung teilt dem Webbrowser mit, welche Klassendatei er aus dem Netz

laden und ausführen muß. Beachte, daß auch hier Groß- und Kleinschreibung relevant ist! ♦ Die Angaben WIDTH und HEIGHT geben den Platz an, der dem Applet auf der HTML-

Seite eingeräumt wird.


15

II. Grundlegende Sprachelemente


II. Grundlegende Sprachelemente 16

1. Anweisungen und Kommentare 1.1 Anweisungen und Anweisungsblöcke ♦ Anweisungen enden immer mit einem Semikolon! ♦ Anweisungsblöcke werden mit geschweiften Klammern gebildet. ♦ Anweisungsblöcke können dort verwendet werden, wo sonst nur eine einzelne Anweisung

von Java erwartet würde. 1.2 Kommentare ♦ Nach "//" wird der Rest der Zeile als Kommentar betrachtet ♦ Kommentarblöcke können durch "/* ... */" gebildet werden ♦ Javadoc-Kommentare sind durch "/** .. */" gekennzeichnet. Javadoc ist ein

System, das aus einem derart kommentierten Quellcode automatisch eine Quelltext-Dokumentation im HTML-Format erzeugen kann und ist Bestandteil des JDK von Sun.

Beispiel: a = b + c; // Hier wird was gerechnet /* Das Leben ist eher kurz als lang und wir stehen alle mittenmang. */ if ( a < 10 ) { d = a * 2; e = b + 1; } Beachte: ♦ Vorsicht beim Schachteln von Kommentaren! /* Das Leben ist eher kurz als lang /* Zeit ist ohnehin relativ, wie Einstein schon festgestellt hat. */ // An dieser Stelle haben wir jetzt ein Problem! und wir stehen alle mittenmang. */



2. Variablen und primitive Datentypen 2.1 Variablennamen ♦ Variablennamen dürfen mit einem Buchstaben, Unterstrich "_" oder Dollarzeichen "$"

beginnen. ♦ Groß- und Kleinschreibung wird wie überall in Java auch bei Variablennamen

unterschieden. ♦ Variablennamen dürfen sehr lang werden. ♦ Konvention ist, den ersten Buchstaben immer klein zu schreiben und folgende Worte mit

einem Großbuchstaben zu beginnen, ohne "$" und "_" zu verwenden: boolean dieseVariableSpeichertObDiePersonVerheiratetIst; 2.2 Primitive Datentypen Datentyp Wertebereich boolean true oder false byte -128 bis 127 short -32768 bis 32767 int -231 bis +231 long -263 bis +263 –1 float 32 Bit Gleitpunktzahl double 64 Bit Gleitpunktzahl char Ein einzelnes Zeichen Beachte: ♦ boolean ist ein eigener Datentyp mit den Literalen true und false! ♦ Die Wertebereiche sind auch auf verschiedenen Plattformen bei Java immer identisch! ♦ Zeichenketten (Strings) sind in Java Objekte, kein primitiver Datentyp! ♦ Eigene Datentypen können nicht definiert werden, jedoch eigene Objekte! 2.3 Variablen deklarieren int schuhgroesse; float meineGroesse; boolean maennlich; long meinWunschGehalt, deinWunschGehalt; Beachte: ♦ Variablendeklarationen können an beliebiger Stelle innerhalb einer Methode stehen,

solange sie vor ihrer ersten Verwendung deklariert werden. ♦ Java kennt keine globalen Variablen. ♦ Java unterscheidet Klassen-, Instanz- und lokale Variablen (mehr dazu später).



2.4 Variablen initialisieren: int schuhgroesse = 43; float meineGroesse = 1.76; boolean maennlich = true; int x, y, z = 5; // x und y nicht initialisiert! int x = 5, y = 5, z = 5; // so ist's recht! Beachte: ♦ Instanz- und Klassenvariablen bekommen default-Initialisierungen (0, false, null, '\0' ). ♦ Lokale Variablen sollten immer initialisiert werden. 2.5 Werte an Variablen zuweisen int x = 5; int y; y = 6; y = x + 3; x = y = 10; Beachte: ♦ Eine Zuweisung ist auch ein Ausdruck, dessen Wert der zugewiesenen Wert ist (siehe

letzte Anweisung oben)! Dies ist eine potentielle Fehlerquelle, manchmal aber auch nützlich.

2.6 Variablen ausgeben (Beispiel) public class Test { public static void main( String[] args ) { int x = 5; double d = 10.357; System.out.println( x ); System.out.println( "x = " + x + " und d = " + d ); } }



3. Literale int x = 4; long y = 4L; int z = 0xC000; // hexadezimale Angabe mit 0x int a = 0777; // oktale Angabe mit führender Null double d = 1.23; float f = 1.23F; double e = 1E-4; // 0.0001 boolean wahr = true; boolean falsch = false; char c = 'c'; char newline = '\n'; Zeichenliteral Beschreibung \n newline \t tab \b backspace \r return \f formfeed \\ \ \' ' \" " \777 Oktale Angabe \xC000 Hexadezimale Angabe \u1234 Unicode-Zeichensatz String undefinierterString = null; String einTitel = "Programmieren mit Java"; String leererString = ""; String text = "In M\u00fnchen sagt man \"O’zapft is!\""; \\ In München sagt man "O’zapft is!" Beachte: ♦ Zeichen und Zeichenketten werden in Java im 16-Bit-Unicode-Format verarbeitet und

gespeichert. Das bedeutet, daß Sie z. B. auch hebräische oder andere Schriftzeichen bei der Ein- und Ausgabe von Datenströmen verwenden können.

♦ Die Verwendung von Unicode-Zeichen erfolgt mit \u (siehe oben), gefolgt vom Zahlencode des entsprechenden Zeichens.

♦ Ob die korrekte Ausgabe aller Unicode-Zeichen jedoch möglich ist, hängt vom Laufzeitsystem und den dort verfügbaren Zeichensätzen ab.

Umlaut Ä ä Ö ö Ü ü ß Unicode \u00c4 \u00e4 \u00d6 \u00f6 \u00dc \u00fc \00df



4. Operatoren 4.1 Arithmetische Operatoren x = 5 + 2; y = 3 – 2; z = 4 * 8 / 2; i = 47 % 11 // Modulo-Rest der Division: i = 3 4.2 Inkrementieren und Dekrementieren x = 1; // x = 1 Postfix-Notation x++; // x = 2 y = x++; // y = 2, x = 3 x = 1; // x = 1 Prefix-Notation y = ++x; // y = 2, x = 2 ♦ Analog arbeitet der Operator --. 4.3 Bitweise Operatoren & AND | OR ^ XOR ~ Komplementbildung << Linksschieben >> Rechtsschieben >>> Rechtsschieben, mit Null füllen 4.4 Zuweisungsoperatoren a = b = c = d = 5; // a = ( b = ( c = ( d = 5 ) ) ); a += 2; // a = a + 2; b -= 3; // b = b – 3; c *= 4; // c = c * 4; d /= 5; // d = d / 5; e %= 2; // e = e % 2; ♦ Analog arbeiten die Operatoren <<=, >>=, &=, |=, ^=



4.5 Logische Operatoren & && AND | || OR ^ XOR ! NOT Beachte: ♦ Bei Verwendung der Form

if ( AusdruckA & AusdruckB ) werden beide Ausdrücke ausgewertet und dann das Ergebnis gebildet.

♦ Bei Verwendung der Form if ( AusdruckA && AusdruckB ) wird zunächst AusdruckA ausgewertet. Wenn daraus allein schon das Endergebnis feststeht, wird AusdruckB nicht weiter beachtet.

4.6 Vergleichsoperatoren == gleich != ungleich < kleiner als > größer als <= kleiner oder gleich >= größer oder gleich Beachte: ♦ Zuweisungen mit =, Vergleiche mit == ♦ Häufiger Fehler, da Zuweisung auch als Wert interpretiert wird:

boolean result = false; if( result = true ) ... // ist immer wahr -> result wird true zugewiesen, dann erst Vergleich! Abhilfe: if( true == result ) ... (Compiler würde meckern) oder if( result )...

♦ Bei Vergleich zwischen Objekten wird auf Identität geprüft, nicht auf inhaltliche Gleichheit: GregorianCalendar a = new GregorianCalendar( 2001, 5, 17 ); GregorianCalendar b = new GregorianCalendar( 2001, 5, 17 ); GregorianCalendar c = a; if ( a == b ) ... // false if ( a.equals( b ) )... // true ( Inhaltlicher Vergleich ) if ( a == c ) ... // true ( Identität )



5. Arrays ♦ Ein Feld (Array) speichert eine Liste von Werten ♦ Die Werte müssen alle vom gleichen Typ sein ♦ Der Typ ist ein beliebiger Objekttyp oder einfacher Datentyp ♦ Auf die Elemente kann über die Nummer (Index) des Elementes zugegriffen werden ♦ Die Größe des Arrays ist nicht variabel. 5.1 Deklarieren von Arrays int[] preise; String[] artikelNamen; 5.2 Erzeugen von Arrays preise = new int[ 10 ]; String[] artikelNamen = new String[ 10 ]; Beachte: ♦ Der Wert in den eckigen Klammern gibt die Anzahl der Elemente, nicht den höchsten

Indexwert an! 5.3 Initialisieren von Arrays: String[] namen = { "Claudia", "Simone", "Eva" }; Hinweis: ♦ Array-Elemente werden default mit ( 0, false, '\0', null ) initialisiert. 5.4 Zugriff auf Array-Elemente: String[] namen = { "Claudia", "Simone", "Eva" }; namen[ 2 ] = "Marlene"; System.out.println( namen[ 0 ] ); // gibt "Claudia" aus Beachte: ♦ Das erste Element hat den Index Null! 5.5 Größe von Arrays feststellen: ♦ Die Größe eines Arrays läßt sich mit length prüfen: String[] namen = { "Claudia", "Simone", "Eva" }; int drei = namen.length;



Beachte: ♦ Häufiger Schreibfehler: length ist keine Methode! String a1 = "The quick brown fox jumps over the lazy dog."; String[] a2 = { "Claudia", "Simone", "Eva" }; int i1 = a1.length(); int i2 = a2.length; // !!! 5.6 Mehrdimensionale Arrays ♦ In Java gibt es keine mehrdimensionalen Arrays, aber Arrays aus Arrays sind möglich: int[] werte1 = new int[ 2, 3 ] // geht nicht! int[][] werte2 = new int[ 2 ][ 3 ] // geht! werte[ 2 ][ 1 ] = 4711; 5.7 Arrays kopieren ♦ Arrays lassen sich mit der Methode arraycopy aus dem Paket System kopieren: System.arraycopy( Quelle, QStart, Ziel, ZStart, Anzahl ); Beispiel: int[] a = { 1, 2, 3, 4, 5 }; int[] b = new int[ 5 ]; b[ 0 ] = 9; b[ 1 ] = 10; System.arraycopy( a, 1, b, 2, 3 ); // b = { 9, 10, 2, 3, 4 } Beachte: ♦ In Java können Methoden auch beliebige Arrays von Objekten übergeben werden oder sie

können solche erzeugen: public String[] getNames() { ... } ♦ Die Klasse Vector aus dem Paket java.util ermöglicht Arrays variabler Größe, bei

denen die Elemente auch verschiedenen Typs sein können. ♦ Arrays werden wie Objekte als Referenz übergeben! Dies ist unbedingt zu beachten, wenn

man z. B. ein Array bei einem Methodenaufruf übergibt: Manipulationen des Arrays innerhalb der Methode wirken sich dann auch auf die aufrufende Umgebung aus!



6. Fallunterscheidungen 6.1 if-Anweisung if( Bedingung ) AnweisungA; else AnweisungB;

if(Bedingung ) { AnweisungenA } else { AnweisungenB }

♦ Wenn die Bedingung erfüllt ist, wird der erste Anweisungsblock ausgeführt, sonst der

zweite. ♦ Für Bedingung kann ein Vergleich, eine boolesche Variable oder ein Methodenaufruf

verwendet werden, der einen boolean-Wert zurückgibt. Beachte: ♦ Auch wenn der if-Teil nur aus einer Anweisung besteht, kommt vor dem else-Teil ein

Semikolon! Beispiel: if ( x < 5 ) System.out.println( "X ist kleiner als fünf" ); if ( y > 4 ) { a = y * 3 + 7; b = y + 2 - a; } else b = y + 1; Hinweis: Betrachte folgenden Fall: if ( x < 5 ) if ( x > 2 ) System.out.println( "2 < x < 5" ); else System.out.println( "x <= 2" ); Dieser Fall wird in der Literatur als "Dangling Else" bezeichnet. Java ordnet hier ein else immer dem letzten if zu. Ein abweichendes Verhalten läßt sich durch entsprechende Klammerung erreichen: if ( x < 5 ) { if ( x > 2 ) System.out.println( "2 < x < 5" ); } else System.out.println( "x >= 5" );



6.2 Bedingungsoperator ( Bedingung ? WertA : WertB ) ♦ Wenn die Bedingung erfüllt ist, hat dieser Ausdruck den WertA, sonst den WertB. Beispiel: int x = 5; int y = 8; int maximum = ( x > y ? x : y ); // maximum ist jetzt 8 Tip für später: ♦ Dieser Operator kann z. B. eine "NullPointerException" (Laufzeitfehler) verhindern: System.out.println( ( name == null ? "" : name ).length() ); 6.3 switch-Anweisung switch ( Ausdruck ) { case Wert1: Anweisung1; break; case Wert2: Anweisung2; break; default: Anweisung3; }

if ( Ausdruck == Wert1 ) Anweisung1; else if ( Ausdruck == Wert2 ) Anweisung2; else Anweisung3;

♦ Die switch-Anweisung verhindert "else-if-Orgien" und das Wiederholen des

Ausdrucks ♦ Der default-Teil wird ausgeführt, wenn keine der case-Fälle zutrifft. Er kann auch

wegfallen. Beachte: ♦ Ausdruck darf nur ein primitiver Datentyp sein, dessen Casting nach int möglich ist, also

z. B. long, int, char etc., nicht aber ein String! ♦ Ohne die Anweisung break; werden die folgenden Blöcke ebenfalls ausgeführt, bis zum

nächsten break; (Potentielle Fehlerquelle).



Beispiel: public class Test { public static void main( String[] args ) { char x = args[ 0 ].charAt( 0 ); // ersten Buschstaben des ersten Parameters ermitteln switch ( x ) { case 'a': case 'b': System.out.println("Das Zeichen ist ein a oder b"); break; case 'c': System.out.println("Das Zeichen ist ein c"); case 'd': System.out.println("Das Zeichen ist ein c oder d"); break; default: System.out.println("Kein a, b, c oder d"); } } } Aufruf: java Test c Ausgabe: Das Zeichen ist ein c Das Zeichen ist ein c oder d



7. Schleifen 7.1 for-Schleifen for( Initialisierung; Bedingung; Inkrement ) { Anweisungen }

♦ Die Anweisung Initialisierung wird vor dem ersten Eintritt in den Schleifenblock

ausgeführt. ♦ Die Anweisung Inkrement wird nach jedem Durchlauf des Schleifenblock ausgeführt. ♦ Vor jedem Durchlauf wird die Bedingung geprüft und, falls diese erfüllt ist, ein

nochmaliger Durchlauf gestartet. Beispiel: for( int i = 0; i < 3; i++ ) { System.out.println( "Die Variable i hat den Wert " + i ); } Hinweis: ♦ In der Anweisung Initialisierung deklarierte Variablen sind nur lokal im Schleifenblock

bekannt. ♦ Der Schleifenblock kann bei allen Schleifenarten auch nur aus einer einzelnen Anweisung

ohne geschweifte Klammern bestehen ♦ Alle Elemente der Schleife können leer sein, wenn man sie nicht benötigt, also z. B. for( ; Bedingung; ) { Anweisungen } for( Initialisierung; Bedingung; Inkrement ); Beachte: ♦ Ein häufiger Fehler ist ein versehentliches Semikolon hinter der Klammer: for ( i = 0; i < 10; i++ ); System.out.println( "Oh, oh, bin nicht in der Schleife!" );



7.2 while-Schleifen while( Bedingung ) { Anweisungen } ♦ Vor jedem Schleifendurchlauf wird die Bedingung geprüft, auch vor dem ersten Eintritt in

die Schleife Beispiel: int x = 20, y = 30; while ( Math.abs( x - y ) < 100 ) // Solange Differenz < 100 { System.out.println( "x=" + x + ", y=" + y ); x -= 10; y += 5; } 7.3 do-while-Schleifen do { Anweisungen } while( Bedingung ); ♦ Die Schleife wird mindestens einmal durchlaufen. ♦ Nach jedem Durchlauf wird die Bedingung geprüft und ggf. die Schleife verlassen. Beispiel: int x = 0; do { x = x * 2 + 1; System.out.println( x ); } while( x < 100 );



7.4 Schleifen unterbrechen ♦ Die Anweisung break; verläßt die gesamte Schleife und setzt die Programmausführung

hinter der Schleife fort ( bei verschachtelten Schleifen wird also die nächsthöhere Ebene angesprungen)

♦ Die Anweisung continue; beendet nur den aktuellen Schleifendurchlauf und setzt die Schleife mit einem neuen Durchlauf fort.

Beispiel: for( int i = 1; i < 100; i++ ) { if( i % 3 == 0 ) continue; System.out.println( "i ist: " + i ); System.out.println( "i zum Quadrat ist:" + i * i ); } 7.5 Schleifen benennen ♦ Schleifen können durch ein Label gefolgt von einem Doppelpunkt benannt werden: raushier: for( int i = 1; i < 10; i++ ) { while( irgendwasIstWahr ) { tuWas(); if ( etwasSchrecklichesIstPassiert ) break raushier; } } Beachte: ♦ Wo wir gerade bei Labeln sind: goto ist in Java ein reserviertes Schlüsselwort, wird aber

nicht verwendet! Übung: ♦ Schreiben Sie ein Java-Programm, das mit Hilfe von zwei verschachtelten Schleifen alle

Zahlenpaare größer als Null ausgibt, deren Summe kleiner als fünf ist.



8. Methoden ♦ Methoden entsprechen den Prozeduren und Funktionen in anderen Programmiersprachen. 8.1 Methoden aufrufen ♦ Methoden werden über ihren Namen aufgerufen. ♦ Methoden gehören in der Regel zu einem Objekt. Der Name des Objektes wird dem

Namen der Methode vorangestellt, gefolgt von einem Punkt. ♦ Beim Aufruf kann Ihnen eine Liste von Parametern mitgegeben werden, die aus Variablen

oder Objekten besteht. ♦ Methoden können einen Variablenwert, ein Array, ein Objekt oder gar nichts

zurückgeben. Beispiele: System.out.println( "Hallo Welt!" ); ... String name = "Willi Winzig"; int anzahlZeichen = name.length(); System.out.println( name.toUpperCase() ); System.out.println( "John Doe".length() ); // Ausgabe = 8 8.2 Methoden definieren Beispiele: public class MethodenTest { public static void sagHallo() { System.out.println( "Hallo Welt!" ); } public static void gruss( String name ) { System.out.println( "Hallo " + name + "!" ); } public static double mittelwert( double x, double y ) { double mw = ( x + y ) / 2; return mw; } public static void main( String[] args ) { sagHallo(); gruss( "Peter" ); double x = 7.8; double y = mittelwert( 3.5, x ); System.out.println( mittelwert( 10.2, 9.45 ) ); } }



Allgemeine Syntax einer Methodendeklaration: Modifier Rückgabetyp Methodenname( Parameterliste ) { Anweisungen } ♦ Rückgabetyp legt den Datentyp fest, der nach Beendigung der Methode von dieser

zurückgegeben wird. Methoden, die nichts zurückgeben, bekommen den Datentyp void. ♦ Methoden können auch Arrays oder Objekte zurückgeben ♦ Methoden ohne Rückgabe (void) heißen in anderen Programmiersprachen oft

"Prozeduren". ♦ Methoden mit Rückgabe heißen in anderen Programmiersprachen oft "Funktionen". ♦ Parameterliste ist die Liste der Parameter, die der Methode mit übergeben werden,

jeweils mit der Angabe des Datentyps und einem Variablennamen, getrennt durch Kommata.

♦ Die Parameterliste kann leer sein, die Klammern sind unbedingt anzugeben! ♦ Mit der Anweisung return wird die Methode verlassen und ein Wert zurückgegeben. ♦ Bei void-Methoden wird die return-Anweisung weggelassen. ♦ Methoden können in Java 1.0 nur innerhalb einer Klasse und außerhalb jeder anderen

Methode deklariert werden. Ab Java 1.1 ist es mit "Inner Classes" möglich, in gewisser Weise Klassen und Methoden innerhalb anderer Klassen und Methoden zu deklarieren (mehr dazu später).

8.3 Parameterübergabe an Methoden, Rückgabe von Werten ♦ Bei einfachen Datentypen (int, double, boolean usw.) wird stets nur der Wert,

nicht die Variable an sich übergeben (call by value). ♦ Bei Objekten und Arrays wird eine Referenz auf das Objekt, also an sich das Objekt selbst

unter einem neuen Namen, übergeben (call by reference). ♦ Gleiches gilt für einen eventuell von der Methode zurückgegebenen return-Wert. Beispiel: public class Verdoppeln { public static int doppelt( int zahl ) { zahl = zahl * 2; // zahl ist hier eine lokale Variable! return zahl; } public static void main( String[] args ) { int zahl = 10; System.out.println( zahl ); // 10 System.out.println( doppelt( zahl ) ); // 20 System.out.println( zahl ); // 10 } }



9. Arbeiten mit Zeichen und Zeichenketten 9.1 Die Klasse String Strings erzeugen String a = new String(); String s = "Mein Name ist Hase."; char[] c = { 'T', 'i', 'n', 'a' }; String b = new String( c ); // ... und weitere Konstruktoren Länge eines Strings String s = "Mein Name ist Hase."; int l = s.length(); // l = 19 Suchen in Strings String s = "Mein Name ist in Namibia bekannt."; int i = s.indexOf( "Nam" ); // i = 5 int j = s.indexOf( "Hund" ); // i = -1 int k = s.lastIndexOf( "Nam" ); // k = 17 int k = s.indexOf( "Nam", 10 ) // k = 17, ab 10. Zeichen Teile von Strings String s = "Mein Name ist in Namibia bekannt."; char c = s.charAt( 0 ); // c = 'M' String w = s.substring( 5, 9 ); // w = "Name", Zeichen 5 – 8 String y = s.substring( 17 ); // w = "Namibia bekannt." Veränderte Ausgabe von Strings String s = "Drei Chinesen mit dem Kontrabaß"; String t = s.replace('e','i').replace('o','i').replace('a','i'); // t = "Drii Chinisin mit dim Kintribiß" String c = "Monica loves Bill"; String d = c.toUpperCase(); // "MONICA LOVES BILL" String u = c.toLowerCase(); // "monica loves bill" Beachte: ♦ Instanzen von String sind nicht veränderlich, d. h. obige Methoden geben einen

entsprechenden neuen String zurück, statt den alten zu verändern (Strings sind Objekte, nicht vergessen)!



Vergleichen von Strings String a = "Inflationsgefahr"; String b = "Inflation"+a.charAt(9)+"Gefahr".toLowerCase(); String c = "infLATionsGefaHr"; if ( a == b ) ... // false !!! if ( a.equals( b ) ) ... // true if ( a.equalsIgnoreCase( c ) ) ... // true if ( a.startsWith( "Inflation" ) ) ... // true if ( a.endsWith( "Ende" ) ) ... // false String x = "Verona Feldbusch"; String y = "Morgens Aronal, abends Elmex" // Werbeeinnahmen! boolean b = x.regionMatches( 2, y, 9, 4 ); // "rona" -> true boolean ignoreCase = true; b = x.regionMatches( ignoreCase, 2, "ARONAL", 1, 4 ); // true String a1 = "Ameisenbär"; String a2 = "Braunbär"; int c = a1.compareTo( a2 ); // c < 0 // = 0 falls a1.equals( a2 ) // < 0 falls a1 lexikographisch vor a2 // > 0 falls a1 lexikographisch nach a2 Einfaches Verketten von Strings String s = "Eins"; String t = "Zwei"; String u = s + t; String v = s.concat( t ); Beachte: ♦ Viele Zeichenketten sollten besser mit Hilfe der Klasse StringBuffer verkettet

werden!! ♦ length() liefert die Anzahl Zeichen, nicht die letzte Indexposition im String! ♦ substring( von, bis ) liefert den Teilstring bis vor dem Zeichen an der Position bis! ♦ replace() kann nur komplett alle Vorkommen eines Zeichens ersetzen, aber keine

Teilstrings durch andere ersetzen! ♦ indexOf() etc. liefern bei erfolgloser Suche den Wert -1 Hinweis: ♦ Die Klasse String ist für statische Zeichenketten gedacht. ♦ StringBuffer realisieren dynamische, änderbare Zeichenketten.



9.2 Die Klasse StringBuffer StringBuffer erzeugen StringBuffer st = new StringBuffer(); StringBuffer st = new StringBuffer( "Ein Text" ); Variablenwerte an den StringBuffer anhängen st.append( Variable ); ♦ Die Methode append existiert in Varianten für boolean, char, double,

float, int, long und String Variablenwerte in den StringBuffer einfügen st.insert( Position, Variable ); ♦ Die Methode insert existiert in Varianten für boolean, char, double,

float, int, long und String und fügt den Wert an der Stelle Position in den StringBuffer ein.

Länge eines StringBuffers StringBuffer st = new StringBuffer( "Ein kurzer Text" ); int len = st.length(); // len = 15 st.setLength( len – 10 ); // st = "Ein k" Auf einzelne Zeichen zugreifen StringBuffer st = new StringBuffer( "Ein kurzer Text" ); char c = st.charAt( 1 ); // c = 'i' st.setCharAt( 13, 's' ); // "Ein kurzer Test" StringBuffer-Inhalt umdrehen: StringBuffer st = new StringBuffer( "Frank" ); st.reverse() System.out.println( st.toString() ); // Ausgabe "knarF" StringBuffer in String umwandeln String s = st.toString();



9.3 Die Klasse Character ♦ Die Klasse Character ist eine sogenannte Wrapper-Klasse für den einfachen Datentyp

char (mehr zu Wrapper-Klassen später). ♦ Sie besitzt einige nützliche Methoden, um mit einzelnen Zeichen (Datentyp char) zu

arbeiten. Zeichentyp bestimmen char c = 'a'; boolean b1 = Character.isDigit( c ); // true, falls c eine Ziffer ist boolean b2 = Character.isLetter( c ); // true, falls c ein Buchstabe ist boolean b3 = Character.isLetterOrDigit( c ); // ... boolean b4 = Character.isSpace( c ); // true, falls c Leerzeichen, \t, \n, \f, \r boolean b5 = Character.isJavaLetter( c ); // true, falls isLetter( c ) oder '$' oder '_' boolean b6 = Character.isJavaLetterOrDigit( c ); // ... boolean b7 = Character.isLowerCase( c ); // true, falls c ein Kleinbuchstabe ist boolean b8 = Character.isUpperCase( c ); // true, falls c ein Großbuchstabe ist Zeichen umwandeln char c = 'a'; char d = 'B'; char e = Character.toLowerCase( d ); // e = 'b' char f = Character.toUpperCase( c ); // f = 'A' String s = Character.toString( c ); // s = "a"




37

III. Objektorientierte Programmierung mit Java


III. Objektorientierte Programmierung mit Java 38

1. Objekte und Klassen Objekt ♦ besitzt Variablen (Attribute), die den Zustand des Objektes beschreiben. ♦ besitzt Methoden, über die auf das Objekt zugegriffen wird, die mit den Attributen

arbeiten und die das Verhalten des Objektes festlegen. ♦ dadurch Verbindung der Daten und der Prozeduren, die mit diesen Daten arbeiten. Klasse ♦ Menge von gleichartigen Objekten ♦ Definition der Attribute und Methoden aller Objekte dieser Klasse Instanz (engl. instance, besser übersetzt als "Exemplar") ♦ Zur Laufzeit gebildetes konkretes Objekt aus einer Klasse Beispiele: Klasse: Konto Attribute: Kontostand, Kontoinhaber, Kontonummer Methoden: einzahlen, abheben, überweisen Instanz: Das Konto mit der Kontonr. 1234243 Klasse: Point aus dem Paket java.awt Attribute: x, y Methoden: move, translate, ... Instanz: Der Punkt ( 10, 45 ) Beachte: ♦ Jedes Java-Programm besteht aus einer Sammlung von Klassen, in denen Variablen und

Methoden definiert werden ♦ Zur Laufzeit werden entsprechend den Anweisungen Instanzen von Objekten der Klassen

erzeugt, die gegenseitig ihre Methoden aufrufen und ihre Variablen verwenden. Wichtige Ziele objektorientierter Programmierung: ♦ Anwendungssysteme als Abbildung der Objekte der realen Welt modellieren:

Objekte Produkt, Kunde, Lieferant, Rechnung, Auftrag, ... Modellierung soll einfacher und korrekter werden

♦ Wiederverwendung von Code ermöglichen: Probleme nur einmal lösen! (Objekte in verschiedenen Anwendungen nutzen, durch Vererbung spezialisieren...)

♦ Auswirkungen von Änderungen lokal halten, auf Objekt beschränken (Pflegbarkeit des Codes erhöhen, Fehleranfälligkeit minimieren)



2. Lebenszyklus und Verwendung von Objekten 2.1 Objekte erzeugen ♦ Objekte werden durch Aufruf eines Konstruktors erzeugt. Dies geschieht durch

Verwendung des Schlüsselwortes new. GregorianCalendar heute = new GregorianCalendar(); //parameterloser “Standardkonstruktor“ GregorianCalendar damals = new GregorianCalendar(1971,3,22); Point hier = new Point( 10, 45 ); ♦ Konstruktoren dienen dem Erzeugen von Objekten und legen dessen Anfangszustand fest. ♦ Konstruktoren werden durch new Klassenname( Parameter ) aufgerufen und

geben ein Objekt dieser Klasse zurück. 2.2 Objekte verwenden ♦ Auf Variablen und Methoden eines Objektes wird durch Voranstellen des Objektnamens,

gefolgt von einem Punkt, zugegriffen: import java.awt.Point; ... Point hier = new Point( 10, 45 ); hier.translate( 2, 0 ); // verschieben um 2 nach rechts System.out.println( "x = " + hier.x ); System.out.println( "y = " + hier.y ); hier.x = 8; // hier.move( 8, 20 ); täte dasselbe hier.y = 20; System.out.println( "x = " + hier.x ); System.out.println( "y = " + hier.y ); ♦ Objekte können als Parameter bei Methodenaufrufen übergeben werden und von

Methoden als Rückgabewert zurückgegeben werden. Dabei wird nicht eine Kopie, sondern eine Referenz auf das Objekt übergeben, also quasi das Objekt selbst.

2.3 Objekte zerstören ♦ In Sprachen wie C++ ist es nötig, den von einem Objekt belegten Hauptspeicher wieder

freizugeben, wenn das Objekt nicht mehr verwendet wird. ♦ Java entfernt selbständig Objekte aus dem Speicher, auf die keine Referenz mehr existiert

(Garbage Collection). ♦ Dies geschieht verzögert in regelmäßigen Abständen, bei Speicherknappheit oder kann

manuell durch Aufruf von System.gc(); angestoßen werden.



2.4 Packages verwenden ♦ Java-Klassen können zu Packages (Klassenbibliotheken) geordnet zusammengefaßt

werden. Die wichtigsten Standard-Packages ab JDK 1.1 lauten: java.lang Klassen für grundlegende Sprachbestandteile java.math Klassen und Arithmetik für sehr große Zahlen java.net Netzwerkfunktionalität: URLs, Sockets, Datagramme java.io Ein-/Ausgabe über Datenströme und Dateien java.sql Datenbankzugriffe mit Java Database Connectivity (JDBC) java.text Internationalisierte, formatierte Datums- und Zahlenwerte java.applet Basis- und Hilfsklassen für Java Applets java.awt Abstract Windowing Toolkit: Fenster, Schaltflächen, ... java.awt.datatransfer Clipboard-Funktionen des AWT java.awt.event Ereignisverarbeitung java.rmi Remote Method Invocation (RMI) java.util Hilfsklassen und Utilities java.util.zip Klassen für ZIP / GZIP Datenströme ♦ Klassen aus dem Paket java.lang sind ohne import-Anweisung sofort verfügbar.

Andere Klassen müssen im Kopf einer Klassendeklaration erst importiert werden: import java.awt.Graphics; // Einzelne Klasse, oder aber: import java.awt.*; // Alle Klassen aus java.awt public class HelloWorldApplet ... ♦ Die import-Anweisung macht lediglich dem System die Klassennamen des Paketes

bekannt. Es werden aber nur die Klassen importiert, die zur Laufzeit auch wirklich verwendet werden, nicht automatisch alle Klassen des Paketes!

♦ Unterpakete müssen einzeln importiert werden, z. B. import java.awt.*; import java.awt.event.*;

♦ Alternativ kann der Name des Packages bei jeder Benutzung vorangestellt werden, z. B.: public void paint( java.awt.Graphics g ) { g.drawString( "Hello World", 20, 25 ); } Beachte: ♦ Mit dieser Form des Klassenaufrufs kann man das Problem umgehen, das entsteht, wenn

man zwei Klassen mit dem gleichen Namen aus verschiedenen Paketen verwenden will. ♦ Es lassen sich eigene Packages erstellen (mehr dazu später). ♦ Es existiert eine Namenskonvention, die Konflikte bei Paketnamen vermeiden soll:

♦ Standardpakete aus dem Java-Sprachumfang beginnen mit java ♦ Java-Erweiterungen beginnen mit javax ♦ Pakete von Drittanbietern beginnen mit der Umkehrung des Domainnamens:

www.ibm.com -> Paketnamen beginnen mit com.ibm


http://www.ibm.com/


3. Eigene Klassen erstellen 3.1 Variablen, Konstruktoren und Methoden der Klasse deklarieren ♦ Jede (öffentliche) Klasse wird in einer eigenen Datei deklariert. Dateinamen und

Klassennamen müssen sich entsprechen (class Konto in der Datei Konto.java). ♦ Die Reihenfolge der Deklarationen in der Klasse spielt keine Rolle: public class Klassenname { Variablendeklarationen ... Konstruktorendeklarationen... Methodendeklarationen ... in beliebiger Reihenfolge! } Beispiel: public class Konto { // Attribute: // Welche Werte beschreiben den Zustand dieses Kontos? public String kontoInhaber; public int kontoStand; public int kontoNr; // Konstruktor: wird aufgerufen bei "new Konto(...)" // Was geschieht beim Erzeugen eines neuen Kontos? public Konto( String derKontoInhaber, int dieKontoNr ) { kontoStand = 0; kontoInhaber = derKontoInhaber; kontoNr = dieKontoNr; } // Methoden: // Was kann ich mit einem Konto tun? public void einzahlen( int betrag ) { kontoStand += betrag; } public void abheben( int betrag ) { kontoStand -= betrag; } } ♦ Konstruktoren sind spezielle Methoden eines Objektes, die keinen Rückgabedatentyp

und als Methodenname den Namen der Klasse besitzen. Sie werden aufgerufen, wenn man mit dem Schlüsselwort new eine neues Objekt erzeugt und dienen dazu, den Anfangszustand des neuen Objektes herzustellen.



3.2 Eigene Klassen verwenden: public class Bank { public static void main( String[] args ) { Konto meins = new Konto( "Willi Winzig", 1234823 ); Konto anderes; anderes = new Konto( "John Doe", 1234824 ); meins .einzahlen( 16500 ); // 165 DM anderes.einzahlen( 23400 ); meins .abheben ( 11200 ); meins .einzahlen( 13400 ); anderes.abheben ( 22300 ); System.out.println( meins .kontoStand ); System.out.println( anderes.kontoStand ); } } 3.3 Das Schlüsselwort this ♦ Ein Objekt kann auf seine eigenen Variablen und Methoden durch Voranstellen von this

zugreifen. Insbesondere bei Namensgleichheit von Variablen des Objektes und lokalen Variablen der Methode ist dies sehr nützlich.

♦ Ein Objekt kann this auch verwenden, um eine Referenz auf sich selbst zu übergeben, z. B. mit return( this ); als Rückgabewert oder als Parameter in einem Methodenaufruf.

Beispiel: Variante A: public Konto( String derKontoInhaber, int dieKontoNr ) { kontoStand = 0; kontoInhaber = derKontoInhaber; kontoNr = dieKontoNr; } Variante B (Verwendung von this): public Konto( String kontoInhaber, int kontoNr ) { this.kontoStand = 0; this.kontoInhaber = kontoInhaber; this.kontoNr = kontoNr; }



4. Zugriffsrechte steuern: Modifier public und private Das Problem: Konto meins = new Konto( "Willi Winzig", 1234823 ); meins.einzahlen ( 34500 ); meins.abheben ( 12000 ); meins.kontoStand = 100000; Mit Hilfe der Schlüsselwörter public und private kann man derartige Probleme vermeiden: ♦ public kennzeichnet, daß aus jeder beliebigen Klasse auf die so gekennzeichnete

Variable oder Methode zugegriffen werden darf. ♦ private kennzeichnet, daß nur innerhalb der jeweiligen Klasse selbst auf die so

gekennzeichnete Variable oder Methode zugegriffen werden darf. ... private int kontoStand; ... public void einzahlen( int betrag ) { if( betrag < 0 ) throw new IllegalArgumentException( "betrag < 0" ); kontoStand += betrag; } public void abheben( int betrag ) { if( ( betrag > kontoStand ) || ( betrag < 0 ) ) throw new IllegalArgumentException ( "betrag < 0 oder keine ausreichende Deckung" ); kontoStand -= betrag; } public int gibKontoStand() { return kontoStand; } Beachte: ♦ In den meisten Fällen sollten die Variablen eines Objektes aus oben aufgezeigten Gründen

private deklariert werden und nur mit Zugriffsmethoden wie einzahlen() und abheben() kontrolliert veränderbar sein!

♦ Durch "Datenkapselung" und "Information Hiding" die Integrität und Fehlersicherheit der Objekte schützen!

♦ Das Objekt kann z. B. auch private-Methoden oder -Konstruktoren besitzen, die nur innerhalb des Objektes benutzt werden können und sollen.



5. Klassenvariablen, Klassenmethoden und Konstanten 5.1 Instanz- und Klassenvariablen ♦ Die bisher betrachteten Objektvariablen waren Instanzvariablen, d. h. jede Instanz der

Klasse (also jedes Objekt) besitzt z. B. seine eigene Variable kontoStand. ♦ Durch Voranstellen des Schlüsselwortes static werden Klassenvariablen definiert. ♦ Klassenvariablen existieren nur einmal je Klasse. Alle Objekte dieser Klasse können auf

deren Klassenvariablen zugreifen. Wird eine Klassenvariable geändert, "sehen" alle Objekte automatisch den geänderten Wert.

Beispiel: public class Konto { public static int letzteKontoNr = 0; ... public Konto( String kontoInhaber ) { this.kontoStand = 0; this.kontoInhaber = kontoInhaber; this.kontoNr = ++letzteKontoNr; } public int gibKontoNr() { return kontoNr; } ... } ♦ Die Klassenvariable letzteKontoNr verwaltet die letzte vergebene Kontonummer. ♦ Der Konstruktor der Klasse erhöht jeweils diese Klassenvariable um eins. ♦ Die Klassenvariable muß sinnvollerweise initialisiert werden. ♦ Auf Klassenvariablen kann über den Namen der Klasse oder den Namen eines Objektes

der Klasse zugegriffen werden: Konto meinKonto = new Konto( "Willi Winzig" ); System.out.println( meinKonto.letzteKontoNr ); System.out.println( Konto .letzteKontoNr ); ♦ Sinnvollerweise sollte obige Klassenvariable aber besser private deklariert sein! Beachte: ♦ Klassenvariablen sind nicht an die Existenz einer Instanz der Klasse gebunden, d. h. sie

sind auch dann zugreifbar, wenn derzeit keine Instanz der Klasse existiert!



5.2 Konstanten deklarieren und verwenden ♦ Mit den Schlüsselwörtern final und static werden Konstanten deklariert, d.h.

unveränderbare Variablen. Beispiel: public class Konto { public final static float EURO_DM_KURS = 1.95583F; ... } Verwendung in der Klasse Bank: public class Bank { public static void main( String[] args ) { int dm = 50; int euro = Math.round( dm / Konto.EURO_DM_KURS ); System.out.println( euro ); } }



5.3 Instanz- und Klassenmethoden ♦ Analog zu Klassenvariablen werden mit static Klassenmethoden definiert. ♦ Klassenmethoden sind nicht an die Existenz eines Objektes der Klasse gebunden, d. h. sie

lassen sich auch dann aufrufen, wenn (noch) keine Instanz der Klasse existiert. ♦ Klassenmethoden dürfen daher nur auf Klassenvariablen oder andere Klassenmethoden

der Klasse zugreifen, nicht auf Instanzvariablen oder -methoden. ♦ Klassenmethoden lassen sich durch Voranstellen des Klassennamens oder des Namens

eines Objektes der Klasse aufrufen. Beispiel: public class Konto { public final static float EURO_DM_KURS = 1.95583F; public static int EUROnachDM( int betrag ) { return Math.round( EURO_DM_KURS * betrag ); } ... } Verwendung in der Klasse Bank: public class Bank { public static void main( String[] args ) { int euro = 30; int dm = Konto.EUROnachDM( euro ); System.out.println( dm ); } } Hinweise: ♦ Es können Klassen definiert werden, die nur aus Klassenvariablen und –methoden

bestehen, d. h. es existieren keine Konstruktoren und keine Instanzen der Klasse. ♦ Mit Klassenvariablen und –methoden werden oft Hilfsklassen realisiert, z. B. die Klasse

Math mit den (konstanten) Klassenvariablen PI und E und mathematischen Funktionen. ♦ Die Methode main einer Java-Anwendung ist eine Klassenmethode, da von der Klasse

dieser Anwendung keine Instanz erzeugt wird, wenn die Anwendung gestartet wird. Übung: • Erweitern Sie die Klasse um eine statische Methode zur Umrechnung von DM nach Euro.



6. Klasse Konto (Übersicht) public class Konto { public final static float EURO_DM_KURS = 1.95583F; public static int EUROnachDM( int betrag ) { return Math.round( EURO_DM_KURS * betrag ); } public static int DMnachEURO( int betrag ) { return Math.round( betrag / EURO_DM_KURS ); }

private String kontoInhaber; private int kontoStand; private int kontoNr; public String gibKontoInhaber(){ return kontoInhaber; } public int gibKontoStand() { return kontoStand; } public int gibKontoNr() { return kontoNr; } private static int letzteKontoNr = 0; public Konto( String kontoInhaber ) { this.kontoStand = 0; this.kontoInhaber = kontoInhaber; this.kontoNr = ++letzteKontoNr; } public void einzahlen( int betrag ) { if( betrag < 0 ) throw new IllegalArgumentException( "betrag < 0" ); kontoStand += betrag; } public void abheben( int betrag ) { if( ( betrag > kontoStand ) || ( betrag < 0 ) ) throw new IllegalArgumentException ( "betrag < 0 oder keine ausreichende Deckung" ); kontoStand -= betrag; } }



7. Polymorphismus und Überladen 7.1 Methoden überladen ♦ In Java lassen sich Methoden definieren, die den gleichen Namen, aber eine

unterschiedliche Parameterliste besitzen. ♦ Das Java-System unterscheidet beim Aufruf der Methode anhand der Datentypen der

Parameterliste, welche der angegebenen Methoden auszuführen ist. ♦ Diese Eigenschaft objektorientierter Sprachen nennt man auch Überladen (Overloading)

oder statischer Polymorphismus. ♦ Vergleiche auch z. B. die Definition der Methoden in der Klasse Math für verschiedene

Datentypen int, long, float und double als Parameter! Beispiel: ♦ Zwei Varianten der Methode gibKontoStand(): public class Konto { ... public int gibKontoStand() { return kontoStand; } public int gibKontoStand( boolean inEuro ) { if( inEuro ) return DMnachEURO( kontoStand ); else return kontoStand; } ... } ... Konto k = new Konto( "Meier" ); k.einzahlen( 10000 ); int dm, euro; dm = k. gibKontoStand(); euro = k. gibKontoStand( true ); dm = k. gibKontoStand( false ); Beachte: ♦ In einigen Programmiersprachen ist das Überladen vordefinierter Operatoren ( z. B. "+")

möglich. Dies ist in Java nicht möglich. ♦ Es ist nicht möglich, Methoden mit gleicher Parameterliste, aber verschiedenem

Rückgabewert zu definieren!



Objektorientierte Denkweise: ♦ Wenn zwei Methoden das gleiche tun, sollten Sie auch gleich heißen. ♦ Vereinfache die Benutzung und ermögliche Wiederverwendung durch Flexibilität. ♦ Lasse nicht den Programmierer, sondern den Compiler oder das System zur Laufzeit

entscheiden, welche Aktion die richtige ist, wenn bestimmte Parameter oder Objekte verwendet werden.

7.2 Konstruktoren überladen ♦ Oft werden auch Konstruktoren überladen. Die Klasse Konto kann z. B. alternative

Konstruktoren anbieten: Beispiel: public class Konto { ... public Konto( String kontoInhaber ) { this.kontoStand = 0; this.kontoInhaber = kontoInhaber; this.kontoNr = ++letzteKontoNr; } public Konto( String kontoInhaber, int betrag ) { this.kontoStand = betrag; this.kontoInhaber = kontoInhaber; this.kontoNr = ++letzteKontoNr; } ... } ♦ Überladene Konstruktoren flexibilisieren die Verwendung der Klasse: Konto k1 = new Konto( "Meier" ); k1.einzahlen( 1000 ); Konto k2 = new Konto( "Schulze", 2000 );



7.3 Überladene Konstruktoren aufrufen • Mit this( Parameterliste ) kann ein überladener Konstruktor einen anderen

Konstruktor der gleichen Klasse aufrufen. • Die this()-Anweisung muß die erste Anweisung in diesem Konstruktor sein! • Dieser Mechanismus wird oft verwendet, wenn ein Konstruktor einem bereits definierten

entspricht, aber zusätzlich z. B. noch weitere Variablen setzt oder weitere Methoden aufruft.

♦ Objektorientierung: Greife auf Bestehendes zurück, löse ein Problem nur einmal. Beispiel: public class Konto { ... public Konto( String kontoInhaber ) { this( kontoInhaber, 0 ); } public Konto( String kontoInhaber, int betrag ) { this.kontoStand = betrag; this.kontoInhaber = kontoInhaber; this.kontoNr = ++letzteKontoNr; } ... } Hinweis zu Konstruktoren: ♦ Ein parameterloser Konstruktor wird Standardkonstruktor genannt. Er soll in der Regel

eine Instanz erzeugen, bei der die Attribute auf bestimmte Standardwerte gesetzt werden. Andere Konstruktoren bieten dann die Möglichkeit, von den Standardvorgaben abzuweichen.

♦ Wird in einer Klasse kein Konstruktor deklariert, erzeugt das System automatisch einen Standardkonstruktor, der nichts tut (außer eine neue Instanz zurückzugeben). Will man dies verhindern, muß man mindestens einen Konstruktor deklarieren. Will man aber verhindern, daß überhaupt Instanzen der Klasse direkt erzeugt werden können, sollte man einen parameterlosen Standardkonstruktor deklarieren, der private ist.



8. Subklassen und Vererbung von Eigenschaften ♦ Objekte bzw. ihre Definition in Klassen können in einer Vererbungsbeziehung stehen,

indem man eine neue Klasse von einer bereits existierenden Klasse ableitet. ♦ Eine Klasse bzw. ein Objekt erbt automatisch alle Eigenschaften (Variablen und

Methoden) der Klasse, von der sie abgeleitet wird. Dies kann über mehrere Ebenen rekursiv erfolgen.

♦ Die erbende Klasse nennt man Subklasse, die vererbende Klasse Superklasse. ♦ Durch Vererbung müssen nur die Teile der Klasse neu angegeben werden, in denen sie

sich von ihrer Superklasse unterscheidet. Beispiel: Superklasse: Konto Attribute: kontoStand, kontoNr, ... Methoden: einzahlen(), abheben(), ... Subklasse: Girokonto Attribute: kontoStand, kontoNr, ... (geerbt),

limit (neu) Methoden: einzahlen(), abheben(), ... (geerbt), setzeLimit(), gibLimit() (neu) ♦ Durch das Schlüsselwort extends wird angezeigt, daß diese Klasse von einer anderen

Klasse abgeleitet ist (d. h. von ihr erbt). ♦ In der Subklasse stehen automatisch alle Methoden und Variablen zur Verfügung, die in

der Superklasse definiert wurden. Code-Beispiel (noch nicht vollständig!): public class Girokonto extends Konto { private int limit; public void setzeLimit( int limit ) { this.limit = limit; } public int gibLimit() { return limit; } } Objektorientierte Denkweise: ♦ Löse ein Problem möglichst generell und nur einmal in einer möglichst

wiederverwendbaren Superklasse. Erweitere die Funktionalität durch Spezialisierung in Subklassen: Ein Girokonto ist eine besondere Art von Konto.

Übung: ♦ Erzeugen Sie eine neue Klasse Girokonto, die von der Klasse Konto abgeleitet ist.



8.1 Konstruktoren und Vererbung ♦ Da Konstruktoren als Methodennamen den Namen ihrer Klasse tragen, können sie im

obigen Sinne nicht vererbt werden. Konstruktoren werden für jede Klasse neu definiert und nicht wie andere Methoden vererbt.

♦ Ein Konstruktor der Subklasse kann (und sollte) jedoch einen Konstruktor der Superklasse über das Schlüsselwort super aufrufen, anstatt dessen Code in der Subklasse nochmals anzugeben.

♦ Fehlt die Angabe von super() in einem Konstruktor, wird beim Aufruf eines Konstruktors der Subklasse automatisch der sog. Standardkonstruktor (derjenige Konstruktor ohne Parameterliste: "super();" ) der Superklasse aufgerufen, falls er existiert.

Beispiel: public class Girokonto extends Konto { ... public Girokonto( String kontoInhaber, int betrag, int limit ) { super( kontoInhaber, betrag ); setzeLimit( limit ); } ... } Übung: ♦ Ergänzen Sie die Klasse Girokonto um einen Konstruktor und schreiben Sie eine Java-

Anwendung, die mit Konten und Girokonten arbeitet und Methoden dieser Klassen aufruft.

Hinweis: ♦ In vielen objektorientierten Sprachen gibt es die Möglichkeit, Klassen zu erstellen, die

von mehreren Klassen abgeleitet sind und die Eigenschaften aller dieser Klassen besitzen. Dies nennt man Mehrfachvererbung. Mehrfachvererbung ist in Java nicht möglich, da damit einige konzeptionelle Schwächen verbunden sind. Viele Probleme, bei denen man in anderen Sprachen Mehrfachvererbung verwenden würde, lassen sich in Java mit Hilfe von Interfaces lösen (mehr dazu später).

♦ Instanzen von Subklassen lassen sich wie Instanzen der Superklasse verwenden, z. B. bei der Übergabe als Parameter an eine Methode, die eine Instanz der Superklasse erwartet:

♦ Da ein Girokonto ein Konto ist, kann man eine Instanz von Girokonto überall dort verwenden, wo ein Konto erwartet wird:

Konto irgendeins = new Girokonto( "Willi", 50000 );



9. Überschreiben von Methoden und Konstruktoren 9.1 Variablenzugriffe und Methodenaufrufe bei Vererbung ♦ Hat man eine Instanz der Subklasse, kann auf alle Variablen zugegriffen und alle

Methoden aufgerufen werden, die ihre Superklasse besitzt. ♦ Bei Vererbung über mehrere Ebenen wird der Aufruf einer Methode von unten nach oben

so weit zur jeweiligen Superklasse durchgereicht, bis eine passende Methode in einer der Superklassen gefunden wird.

9.2 Überschreiben von Methoden ♦ Bei einem Methodenaufruf sucht Java zunächst in der jeweiligen Klasse nach einer

Definition der Methode. Ist die Methode dort nicht definiert, wird die Anfrage nach oben in der Klassenhierarchie weitergereicht und die Superklasse dieser Klasse durchsucht. Auf diese Weise wird die Vererbung realisiert.

♦ Oft möchte man jedoch eine Methode, die bereits definiert war, neu definieren, um sie mit einer erweiterten Funktionalität zu versehen. Dies nennt man Überschreiben (Overriding). Die Methode muß dazu mit der gleichen Parameterliste wie in der Superklasse neu angegeben werden.

Beispiel: ♦ Bei Girokonten darf das Konto bis zum Limit überzogen werden, daher muß die Methode

abheben() überschrieben werden: public class Girokonto extends Konto { ... public void abheben( int betrag ) { if( betrag <= 0 ) throw new IllegalArgumentException ( "Betrag darf nicht <= 0 sein" ); if( betrag > kontoStand + limit ) throw new IllegalArgumentException ( "Sie sind leider zu arm" ); kontoStand -= betrag; } ... } Übung: ♦ Warum läßt sich das Beispiel mit der bisherigen Klasse Konto noch nicht übersetzen?



9.3 Die Zugriffsebene Protected ♦ Eine Subklasse kann nicht auf Methoden oder Variablen ihrer Superklasse zugreifen, die

als private deklariert wurden, jedoch wie jede andere Klasse auf die public –Teile zugreifen.

♦ Methoden und Variablen, die (statt public oder private) als protected deklariert wurden, verhalten sich bezüglich ihrer Subklassen wie public, bezüglich aller anderen Klassen wie private deklariert.

Beispiel: ♦ Damit die Methode abheben() in Girokonto direkt auf die Variable kontoStand der Klasse

Konto zugreifen kann, muss diese als protected statt als private deklariert sein: public class Konto { protected String kontoInhaber; protected int kontoStand; protected int kontoNr; ... } 9.4 Überschriebene Methoden wieder aufrufen ♦ Innerhalb einer überschreibenden Methode kann über das Schlüsselwort "super." auf

die Originalmethode zugegriffen werden: Beispiel: public class X { public void doSomething() { System.out.println( "Greetings from X" ); } } public class Y extends X { public void doSomething() { super.doSomething(); // Gibt "Greetings from X" aus System.out.println( "Greetings from Y" ); } }



9.5 Final-Methoden ♦ Methoden, die als final deklariert werden, können nicht von einer Subklasse

überschrieben werden. ♦ Da der Compiler weiß, daß sich die Methode nicht mehr ändert, kann er ihren Code

optimieren, so daß final-Methoden schneller ausgeführt werden. Aus diesem Grund sind viele Methoden der Java-Standardpakete final, was aber ihre Veränderung in eigenen Subklassen verhindert.

Beispiel: ♦ Einige besonders zeitkritische Methoden der Klasse java.util.Vector sind final,

damit sie schneller ausgeführt werden können. 9.6 Final-Klassen ♦ Klassen, die als final deklariert sind, dürfen nicht abgeleitet werden, d. h. von ihnen

kann keine Unterklasse gebildet werden: public final class Name... ♦ Der Java-Compiler kann die Implementierung solcher Klassen optimieren, da er weiß, daß

die Klasse nicht mehr verändert bzw. erweitert wird. Aus diesem Grunde sind einige Java-Klassen final.

Beispiel: ♦ Die Klasse String ist leider final, da Zeichenkettenverarbeitung zeitaufwendig ist

und die Java-Schöpfer durch die final-Deklaration die schnelle Implementierung von String durch die Laufzeitsysteme ermöglichen wollten.

♦ Man kann demnach nicht einfach eine Subklasse von String erstellen, die die Funktionalität erweitert, z. B. um eine Methode, die Teile von Strings durch andere ersetzen kann.



10. Abstrakte Klassen und Schnittstellen 10.1 Abstrakte Klassen ♦ Von Klassen, die als abstract deklariert werden, können keine Instanzen gebildet

werden. Sie dienen lediglich als Vorlage für daraus abzuleitende Subklassen, die dann die in ihrer abstrakten Superklasse definierten Methoden und Variablen verwenden können.

♦ Abstrakte Klassen dürfen Methoden enthalten, die als abstract deklariert werden und von denen nur die Methodenunterschrift (d. h. Datentyp, Name, Parameterliste) angegeben wird. Nicht-abstrakte Subklassen dieser Klasse sind dann verpflichtet, diese Methoden zu implementieren.

♦ Subklassen abstrakter Klassen können wiederum abstrakt sein. ♦ Mit Hilfe abstrakter Klassen kann der Entwickler dafür sorgen, daß alle Unterklassen

dieser Klasse gewisse Methoden zur Verfügung stellen müssen. Außerdem besitzen diese Subklassen damit eine gemeinsame Superklasse (die abstrakte Klasse). Obwohl diese abstrakt ist, läßt sich dieser Sachverhalt dann z. B. so ausnutzen, daß Objekte dieser abstrakten Klasse als Objekttypen in anderen Methoden anderer Klassen verwendet werden können. Da jede Subklasse auch dort verwendet werden kann, wo ein Objekt der Superklasse erwartet wird und sichergestellt ist, daß alle Subklassen die abstract definierten Methoden implementieren müssen, können so Methoden geschrieben werden, die automatisch mit allen Subklassen der abstrakten Klasse umgehen können.

Beispiel aus der Java Klassenbibliothek: Vgl. die Definition der Klasse Number aus dem Paket java.lang, der abstrakten Superklasse der Wrapper-Klassen Integer, Long, Float und Double. Beispiel: public abstract class Konto // Abstrakte Klasse { ... // Abstrakte Methode public abstract int verfuegbarerBetrag(); public void abheben( int betrag ) { if( betrag < 0 ) throw new IllegalArgumentException( "Betrag < 0" ); if( betrag > verfuegbarerBetrag() ) throw new IllegalArgumentException( "Sorry, zu arm!" ); kontoStand -= betrag; } } (Fortsetzung folgende Seite)



♦ Unterklassen von Konto implementieren die abstrakte Methode: public class Girokonto extends Konto { ... // Implementierung der abstrakten Methode: public int verfuegbarerBetrag() { return kontoStand + limit; } } public class Sparbuch extends Konto { ... // Implementierung der abstrakten Methode: public int verfuegbarerBetrag() { return kontoStand; } } ♦ Andere Klassen können nur Instanzen der nicht abstrakten Unterklassen bilden, können

aber alle Methoden der Klasse Konto, auch auf die abstrakten, aufrufen: public class Bank { public static void main( String[] args ) { Sparbuch sb = new Sparbuch ( "Meier" ); Girokonto gk = new Girokonto( "Müller", 10000 ); bearbeiten( sb ); bearbeiten( gk ); } public static void bearbeiten( Konto k ) { int verfuegbar = k.verfuegbarerBetrag(); System.out.println( "Betrag: " + verfuegbar ); } }



10.2 Schnittstellen

Oft ist die konkrete Klasse eines Objektes eigentlich unwichtig, wichtig ist nur, daß sie ein bestimmtes Verhalten zeigt, d. h. eine bestimmte Methode anbietet. Beim Sortieren eines Arrays ist es beispielsweise eigentlich egal, was in dem Array steht (Strings, Konten, Kunden, ...), solange zwei Array-Elemente sich vergleichen lassen, um die Sortierung durchführen zu können.

♦

♦

♦

♦

♦

Eine mögliche Lösung wäre, alle sortierbaren Klassen von einer abstrakten Superklasse Sortierbar abzuleiten, die eine Methode zum Vergleichen anbietet. Es wird so für alle Subklassen garantiert, daß sie eine Vergleichsmethode anbieten. Das ist jedoch keine gute Lösung: Kunde könnte z. B. eigentlich besser eine Subklasse von PersonenRolle sein, und Mehrfachvererbung ist in Java nicht erlaubt. Kunden und Konten sind auch nicht besonders ähnlich, die gemeinsame Superklasse erscheint sehr gekünstelt. Schnittstellen lösen dieses Problem. Eine Schnittstelle definiert eine Menge von Methoden, ohne deren Implementierung vorzugeben, ähnlich wie bei einer abstrakten Klasse. Beliebige Klassen können nun die Schnittstelle 'implementieren' und müssen dann die entsprechenden Methoden zur Verfügung stellen. Die Klassen und Schnittstellen müssen dann nicht mehr in einer Vererbungsbeziehung stehen. Man kann nun Programmcode schreiben, der mit beliebigen Klassen arbeitet, die eine bestimmte Schnittstelle implementieren, die Art der Klasse ist nun irrelevant. Das macht z. B. die Sortier-Funktion wiederverwendbar und sehr flexibel. Schnittstellen werden durch das Schlüsselwort interface (statt class) eingeleitet. Sie legen die Methoden fest, die alle Klassen anbieten müssen, die die Schnittstelle 'implementieren'.

Beispiel: ♦ Die Schnittstelle Bewertbar definiert das Verhalten bewertbarer Objekte: public interface Bewertbar { public int gibWert(); } ♦ Beliebige Klassen implementieren die Schnittstelle: public abstract class Konto implements Bewertbar { ... public int gibWert() { return kontoStand; } } public class Auto implements Bewertbar { ... public int gibWert() { return kaufpreis * ( 20 – alterInJahren ) / 20; } }



♦ Andere Klassen können gegen die Schnittstelle programmieren, ohne wissen zu müssen, welche konkreten Klassen zur Laufzeit diese Schnittstelle implementieren (vgl. unten die Methode berechneGesamtwert):

public class Vermoegensverwaltung { public static void main( String[] args ) { Sparbuch sb = new Sparbuch( "Meier" ); sb.einzahlen( 30000 ); Auto porsche = new Auto(); Bewertbar[] dinge = new Bewertbar[ 2 ]; dinge[ 0 ] = sb; dinge[ 1 ] = porsche; int summe = berechneGesamtwert( dinge ); System.out.println( summe ); } public static int berechneGesamtwert( Bewertbar[] sachen ) { int summe = 0; for( int i = 0; i < sachen.length; i++ ) summe += sachen[ i ].gibWert(); return summe; } }



10.3 Beispiel: Sortieren eines Arrays: wiederverwendbare Implementierung Das Beispiel zeigt eine wiederverwendbare Implementierung einer Sortierfunktion für Arrays. Es sollen beliebige Arrays von Objekten beliebiger Klassen sortiert werden können. Vorausgesetzt wird nur, daß die Objekte eine Methode vergleiche() zur Verfügung stellen, anhand derer zwei Objekte miteinander verglichen werden können, um die korrekte Reihenfolge zu bestimmen. Die Methode vergleiche() soll je nachdem, welches Objekt als 'größer' betrachtet wird, eine Zahl größer, kleiner oder gleich null zurückgeben (vgl. die Methode compareTo() in der Klasse String, die analog arbeitet): Seien x und y zwei Instanzen der gleichen Klasse, dann soll der Aufruf x.vergleiche(y) einen int-Wert wie folgt zurückgeben: x.vergleiche( y ) ergibt einen Wert < 0 falls x < y x.vergleiche( y ) ergibt einen Wert > 0 falls x > y x.vergleiche( y ) ergibt 0 falls x = y

♦ Erstellen der Schnittstellendefinition in der Datei Vergleichbar.java: public interface Vergleichbar { public int vergleiche( Vergleichbar v ); }

Die Klasse Konto implementiert die Schnittstelle Vergleichbar, d. h. sie stellt eine konkrete Implementierung für die in der Schnittstelle geforderte(n) Methode(n) zur Verfügung. Hier sollen Konto-Instanzen anhand ihres Kontostandes aufsteigend sortiert werden:

♦

public class Konto implements Vergleichbar { ... public int vergleiche( Vergleichbar v ) { Konto other = (Konto)v; return ( this.kontoStand - other.kontoStand ); } }

Instanzen der Klasse Kunde sollen ebenfalls miteinander vergleichbar werden. Die Reihenfolge der Kunden soll anhand ihres Namens bestimmt werden (lexikographische Sortierung):

♦



public class Kunde implements Vergleichbar { protected String name; // Der Name des Kunden public Kunde( String name ) { this.name = name; } public int vergleiche( Vergleichbar v ) { Kunde other = (Kunde)v; return ( this.name.compareTo( other.name ) ); } } ♦ Anwendungen können nun zu Sortierzwecken Kunden und Konten paarweise vergleichen

und dabei einen einheitlichen Aufruf (die Methode der Schnittstelle) verwenden: public class Test { public static void main( String[] args ) { Konto ko1 = new Sparbuch( "Schmidt" ); Konto ko2 = new Sparbuch( "Kling" ); ko1.einzahlen( 20000 ); ko2.einzahlen( 30000 ); int vgl = ko1.vergleiche( ko2 ); System.out.println( vgl ); Vergleichbar ku1 = new Kunde( "Meier" ); Vergleichbar ku2 = new Kunde( "Müller" ); int vgl = ku1.vergleiche( ku2 ); System.out.println( vgl ); } }



♦ Eine Klasse Sortierer, die Arrays von vergleichbaren Objekten sortiert, benutzt nur die Schnittstelle Vergleichbar, ohne etwas über die konkreten Klassen zu wissen, die diese Schnittstelle auf verschiedene Weise implementieren. Sie ist damit völlig unabhängig von einer bestimmten Klasse und wiederverwendbar. Die Klasse bietet eine Methode sortiere(), die ein Array von Instanzen einer die Schnittstelle Vergleichbar implementierenden Klasse mittels QuickSort-Algorithmus sortiert:

public class Sortierer { public static void sortiere( Vergleichbar[] werte ) { quicksort( werte, 0, werte.length - 1 ); } protected static void quicksort( Vergleichbar[] werte, int lo0, int hi0 ) { if( hi0 > lo0 ) { int lo = lo0; int hi = hi0; int mid = ( lo0 + hi0 ) / 2; while( lo <= hi ) { while( ( lo < hi0 ) && ( werte[ lo ].vergleiche( werte[ mid ] ) < 0 ) ) lo++; while( ( hi > lo0 ) && ( werte[ hi ].vergleiche( werte[ mid ] ) > 0 ) ) hi--; if( lo <= hi ) { Vergleichbar temp = werte[ lo ]; werte[ lo ] = werte[ hi ]; werte[ hi ] = temp; lo++; hi--; } if( lo0 < hi ) quicksort( werte, lo0, hi ); if( lo < hi0 ) quicksort( werte, lo, hi0 ); } } } }

Eine beliebige Anwendung kann nun Arrays von Kunden oder Konten sortieren: ♦ Kunde[] kunden = new Kunde[ 10 ]; Konto[] konten = new Konto[ 20 ]; ... // Arrays mit Kunden- und Konto-Instanzen füllen... Sortierer.sortiere( kunden ); Sortierer.sortiere( konten );



Hinweise:

Neue Klassen können später problemlos dem System hinzugefügt werden. Damit auch sie sortierbar sind, müssen sie nur ebenfalls das Interface Vergleichbar implementieren...

♦

♦

♦

Die Plattformunabhängigkeit von Java gründet sich an einigen Stellen auf Schnittstellen, insbes. im AWT (graphische Benutzeroberflächen in Java). Vgl. auch die Schnittstelle Enumeration aus dem Paket java.util und die Schnittstelle Runnable aus dem Paket java.lang!

10.4 Mehrfachvererbung und Implementierung mehrerer Schnittstellen ♦ Da Schnittstellen-Definitionen keine konkreten Implementierungen beinhalten, existieren

hier keine Probleme bei Mehrfachvererbung, daher ist Mehrfachvererbung bei Schnittstellen erlaubt.

public interface XundYundZ extends X, Y { public void doZ(); } ♦ Eine Klasse kann zwar nur eine Oberklasse besitzen, kann aber beliebig viele

Schnittstellen implementieren: public class Girokonto extends Konto implements Bewertbar, Vergleichbar { ... } 10.5 Schnittstellen als Konstantensammlungen ♦ Schnittstellen werden auch oft verwendet, um so etwas wie 'globale Konstanten' zu

definieren. Definiert man in einer Schnittstelle eine Konstante, so ist diese automatisch in jeder Klasse bekannt, die die Schnittstelle implementiert

public interface FinanzKonstanten { public final static float EURO_DM_KURS = 1.95583F; } public class Konto implements FinanzKonstanten { public static int EUROnachDM( int betrag ) { return Math.round( EURO_DM_KURS * betrag ); } public static int DMnachEURO( int betrag ) { return Math.round( betrag / EURO_DM_KURS ); } ... }



11. Eigene Klassen zu Packages zusammenfassen 11.1 Packages definieren

Mit Hilfe des Schlüsselwortes package kann man die Zugehörigkeit einer Klasse zu einem Package definieren. Damit lassen sich Klassen zu Bibliotheken zusammenfassen und übersichtlich verwalten und weitergeben.

♦

♦ Namen von Packages werden per Konvention klein geschrieben. Die package-Anweisung muß die erste Anweisung im Quellcode sein:

package finanzen; // hier kommen ggf. import-Anweisungen hin... public class Konto{ ... } package finanzen.wertpapiere; public class Aktie{ ... }

Die Klassendateien und Quellcodedateien müssen sich dann in einem Unterverzeichnis befinden, das dem Namen des Package entspricht:

♦

♦

♦

Konto.java in .\finanzen\Konto.java Aktie.java in .\finanzen\wertpapiere\Aktie.java

Die Packages lassen sich dann benutzen wie andere Packages auch: import finanzen.*; import finanzen.wertpapiere.*; public class Bank{ ... }

Klassen die sich innerhalb des gleichen Paketes befinden, 'kennen' sich automatisch, es ist dann kein import nötig. Fehlt die Angabe einer Zugehörigkeit zu einem Package, wird das unbenannte 'Standardpaket' angenommen, das dem aktuellen Verzeichnis entspricht. Auch dann ist kein import nötig.



11.2 Zugriffsebenen und Packages

Neben den Modifiern public, protected und private existiert noch eine vierte Zugriffsebene, die die Sichtbarkeit einer Methode oder Variable auf alle Klassen des gleichen Paketes beschränkt. Dazu wird jedoch nicht 'package' vor den Methoden- oder Variablennamen geschrieben, sondern der Modifier weggelassen:

♦

♦

♦

♦

public class xy { int gruppenschluessel = 4711; // kann nur aus Klassen dieses Packages benutzt werden void tuEtwasKritisches(); // darf nur aus Klassen dieses Packages aufgerufen werden }

Auch den Zugriff auf ganze Klassen kann man entweder allen anderen Klassen erlauben public class x { ... } oder auf Klassen des gleichen Paketes beschränken. Nur diese können die Klasse dann benutzen: class y { ... }

Klassen, die nicht public sind, müssen nicht in einer eigenen Quellcodedatei untergebracht sein, sie können sich eine Quellcodedatei mit anderen Klassen teilen. Nichtöffentliche Klassen mit Package-Zugriff ermöglichen es, die Komplexität einer Anwendung zu verbergen. Die import-Anweisung importiert nur public-Klassen, andere Klassen bleiben ihr verborgen.


IV. Nützliches und Wissenswertes 66



IV. Nützliches und Wissenswertes



1. Mathematische Funktionen

Mathematische Funktionen werden durch die Klasse java.lang.Math abgedeckt. ♦ ♦ Da sie Teil des Paketes java.lang ist, ist sie standardmäßig bereits importiert. 1.1 Konstanten Klassenvariable Wert Math.PI Math.E

π als double ( 3.14159...) e als double (2.71828...)

1.2 Trigonometrische Funktionen Klassenmethode Funktion double Math.sin( double Radiant ) sinus double Math.cos( double Radiant ) cosinus double Math.tan( double Radiant ) tangens double Math.asin( double Radiant ) arcsinus double Math.acos( double Radiant ) arccosinus double Math.atan( double Radiant ) arctangens Beachte:

Angabe als Radiant! Bei Angabe als Winkel diesen mit PI/180 multiplizieren! ♦ 1.3 Vergleiche Klassenmethode Funktion Math.max( Zahl1, Zahl2 ) Max für int, long, float, double Math.min( Zahl1, Zahl2 ) Min für int, long, float, double 1.4 Rundungsfunktionen Klassenmethode Funktion Math.round( Zahl ) Auf- / Abrundung für float, double

Ergebnis int bzw. long double Math.rint( double Zahl ) Auf- / Abrundung double Math.floor( double Zahl ) Nächstkleinere ganze Zahl double Math.ceil( double Zahl ) Nächstgrößere ganze Zahl Math.abs( Zahl ) Math.IEEEremainder( Z1, Z2 ) Rest der Division als double

Absolutwert für int, long, float, double



1.5 Exponentialfunktionen und Potenzen Klassenmethode Funktion double Math.pow( double d1, double d2) Potenz d1 hoch d2 double Math.sqrt( double z ) Zweite Wurzel von z double Math.exp( double z ) Potenz e hoch z double Math.log( double z ) Logarithmus naturalis von z 1.6 Zufallszahlen Klassenmethode Funktion double Math.random() Zufallszahl zwischen 0 und 1 Beachte:

Zur Erzeugung von Zufallszahlenfolgen gibt es eine eigene Klasse Random im Paket java.util:

♦

import java.util.Random; ... Random r = new Random(); ... int i = r.nextInt(); // Nächste Zufallszahl long l = r.nextLong(); float f = r.nextFloat(); double d = r.nextDouble(); ... Random r1 = new Random(); // Systemzeit als Seed Random r2 = new Random( seed ); // seed ist vom Typ long ... r2.setSeed( seed ); // seed ist vom Typ long Beachte:

Bei Verwendung identischer Seeds wird die gleiche Folge von Pseudo-Zufallszahlen erzeugt!

♦

♦

♦

♦

1.7 Große Zahlen

Zum Arbeiten mit beliebig großen Zahlen stehen ab JDK 1.1 die Klassen BigDecimal und BigInteger aus dem Paket java.math zur Verfügung. Die Klassen bieten Methoden zum Rechnen mit solchen Zahlen an, die analog zu den mathematischen Standard-Operatoren der Sprache Java sind und diese für große Werte ersetzen. Außerdem sind alle relevanten Methoden aus der Klasse Math analog verfügbar. Weitere Details zu diesen Klassen finden sich in der API-Dokumentation!



2. Datums- und Zeitwerte 2.1 Einfache Zeitstempel

Über die Funktion long jetzt = System.currentTimeMillis(); erhält man die seit Mitternacht am 1. Januar 1970, UTC vergangenen Millisekunden

♦

♦

♦

♦

♦

Darüber hinaus existieren die Klassen Date, Calendar und GregorianCalendar im Paket java.util, um mit Datumswerten zu arbeiten:

2.2 Die Klassen Date und Calendar

Im JDK 1.0 diente die Klasse Date neben der Darstellung eines bestimmten Zeitpunktes auch dazu, diesen Zeitpunkt als ein bestimmtes Kalenderdatum in Tag / Monat / Jahr usw. zu interpretieren und zu verarbeiten. Diese Kalenderfunktionen waren nicht sehr gut auf internationale Anforderungen ausgelegt. Ab JDK 1.1 übernimmt die Klasse Calendar die Aufgabe, ein Datum innerhalb eines Kalendersystems darzustellen. Calendar ist eine abstrakte Klasse, derzeit einzig mitgelieferte konkrete Implementierung ist die Klasse GregorianCalendar. Jede Instanz von Calendar besitzt intern zwei Darstellungen eines Zeitpunktes: zum einen als Datum in Tag, Monat, Jahr usw. aufgeteilt und zum anderen als long-Wert (Anzahl Millisekunden seit 1.1.1970). Diese beiden Darstellungen sind auch getrennt manipulierbar und müssen synchron gehalten werden.

2.3 Datumswerte mit GregorianCalendar anlegen GregorianCalendar c; c = new GregorianCalendar(); // heute c = new GregorianCalendar(1998,11,31 ); // 31.12.1998 c = new GregorianCalendar(1998,11,31,17,32); // um 17:32 h c = new GregorianCalendar(1998,11,31,17,32,15); // und 15 Sek Beachte:

Der Monat wird ab 0 gezählt ( Dezember = 11 )! ♦ ♦ Weitere Konstruktoren legen noch die Zeitzone, Sommer-/Winterzeitabweichung etc. fest. 2.4 Datumswerte vergleichen GregorianCalendar t1 = new GregorianCalendar( 1971, 3, 22 ); GregorianCalendar t2 = new GregorianCalendar( 1976, 9, 6 ); boolean b1 = t1.after ( t2 ); // false boolean b2 = t1.before( t2 ); // true boolean b3 = t1.equals( t2 ); // false



2.5 Datumsteile abfragen GregorianCalendar cal = new GregorianCalendar(); int era = cal.get( Calendar.ERA ); if( era == cal.AD ) System.out.println( "Anno Domini." ); int tag = cal.get( Calendar.DATE ); int monat = cal.get( Calendar.MONTH ); int jahr = cal.get( Calendar.YEAR ); int stunde1 = cal.get( Calendar.HOUR_OF_DAY ); int stunde2 = cal.get( Calendar.HOUR ); int amOrPm = cal.get( Calendar.AM_PM ); int minute = cal.get( Calendar.MINUTE ); int sekunde = cal.get( Calendar.SECOND ); int milli = cal.get( Calendar.MILLISECOND ); int wochej = cal.get( Calendar.WEEK_OF_YEAR ); int wochem = cal.get( Calendar.WEEK_OF_MONTH ); int tagj = cal.get( Calendar.DAY_OF_YEAR ); int moDiMi = cal.get( Calendar.DAY_OF_WEEK ); if( moDiMi == Calendar.SUNDAY ) ... ... und noch ein paar andere für Zeitzone, Sommerzeit etc., siehe API-Dokumentation! 2.6 Datumsteile setzen cal.set( Calendar.YEAR, 1976 ); cal.set( Calendar.MONTH, 9 ); ... Bei Verwendung älterer JDKs sollte man anschließend unbedingt

cal.setTime( cal.getTime() ); aufrufen, wodurch die internen Werte für beide Darstellungen des Zeitpunktes synchronisiert werden. Dies behebt einen Bug in den älteren Java-Laufzeitumgebungen (JDK 1.1). 2.7 Datumswerte mit der Klasse DateFormat ausgeben

Umfangreiche Möglichkeiten der Formatierung über die Klassen DateFormat und SimpleDateFormat aus dem Paket java.text (siehe API-Dokumentation):

♦

GregorianCalendar cal = new GregorianCalendar(); // jetzt DateFormat df = new SimpleDateFormat( "dd.MM.yyyy HH:mm" ); // DateFormat df = // DateFormat.getDateInstance(DateFormat.FULL, Locale.FRANCE); String zeit = df.format( cal.getTime() ); System.out.println( zeit );



3. Die Klasse Object

In Java sind alle Klassen direkt oder indirekt Subklassen der Klasse Object. Wenn für eine Klasse keine Superklasse angegeben ist, wird die Klasse von Object abgeleitet.

♦

♦

♦

Die Klasse Object wird oft dort eingesetzt, wo Methoden allgemein für die Verwendung mit ganz verschiedenen Objekten ausgelegt werden sollen. Da man eine Instanz einer Subklasse überall dort einsetzen darf, wo eine Instanz der Superklasse verwendet wird, kann man z. B. an eine Methode, die ein Object erwartet, jedes beliebige Objekt übergeben. Mit Hilfe des Operators instanceof läßt sich prüfen, ob ein Objekt eine Instanz einer bestimmten Klasse ist.

Beispiel: public static boolean ersterWertKleiner( Object a, Object b ) { if ( a instanceOf String ) { String stra = (String)a; // 'Casting' ist hier nötig String strb = (String)b; return ( stra.compareTo( strb ) < 0 ); } else if ( a instanceof GregorianCalendar ) { GregorianCalendar g1 = (GregorianCalendar)a; GregorianCalendar g2 = (GregorianCalendar)b; return( g1.before( g2 ) ); } else ... } ... boolean b1 = ersterWertKleiner ( "Hund", "Hand" ); boolean b2 = ersterWertKleiner ( new GregorianCalendar( 1997, 7, 11 ), new GregorianCalendar( 1963, 1, 20 ) );

Mit Objekt.getClass() erhält man ein Objekt der Klasse Class, das Informationen über die Klasse des Objektes enthält. Einige nützliche Methoden:

♦

♦

Object o = "Ein String-Objekt"; // oder sonst irgend etwas... Class c = o.getClass(); String klasse = c.getName(); // Name der Klasse Class s = c.getSuperclass(); // Superklasse der Klasse Object x = c.newInstance(); // Neue Instanz dieser Klasse, // funktioniert nur, falls es einen Standardkonstruktor gibt

Ab JDK 1.1 bietet die Java Reflection API im Paket java.lang.reflect wesentlich weitreichendere Möglichkeiten (siehe API-Dokumentation)



4. Nützliche Werkzeuge für den Java-Programmierer 4.1 Die Klasse StringTokenizer

Die Klasse StringTokenizer aus dem Paket java.util dient dazu, einen Teilstring in einzelne Elemente (Tokens) zu zerlegen.

♦

♦ ♦

Die Elemente werden durch Trennzeichen voneinander getrennt. Die Menge der Trennzeichen wird dem Konstruktor als String mit übergeben.

Beispiel: import java.util.StringTokenizer; public class Zerleger { public static void main( String[] args ) { String text = "Eins, zwei oder drei."; String trenn = " ,."; // Blank, Komma, Punkt sind Trenner StringTokenizer st = new StringTokenizer( text, trenn ); while ( st.hasMoreTokens() ) System.out.println( st.nextToken() ); } } // Ausgabe: // Eins // zwei // oder // drei Beachte:

StringTokenizer erwartet als Trenner nur einzelne Zeichen, keine Zeichenketten! ♦ Weitere Konstruktoren st = new StringTokenizer( text ); // Leerzeichen, Tab, Newline als Trenner st = new StringTokenizer( text, delim, returnTokens ); // falls der boolean-Wert returnTokens = true, dann // werden die Trennertoken selbst auch mit zurückgegeben Weitere Methoden der Klasse StringTokenizer int countTokens() // Anzahl Token insgesamt String nextToken( String delim ) // Setzt gleichzeitig eine neue Menge von Trennzeichen



4.2 Wrapper-Klassen

Viele nützliche Methoden der Klassen aus dem Paket java.util sind auf die Verwendung mit Objekten ausgelegt. Ein Problem dieser Methoden ist aber nun, daß ihnen nur Objekte, nicht aber Variablen einfacher Datentypen wie z. B. int übergeben werden können. Für derartige Fälle, in denen man einfache Datentypen wie Objekte behandeln will, stellt Java sogenannte Wrapper-Klassen zur Verfügung, die einfache Datentypen in ein Objekt "verpacken".

♦

♦

♦

Im JDK 1.0 existieren die Wrapper-Klassen Boolean, Character, Double, Float, Integer und Long für die jeweiligen primitiven Datentypen. Ab JDK 1.1 gibt es auch Wrapper-Klassen für Byte, Short und Void. Wrapper-Klassen sind auch nützlich, um Konvertierungen zwischen Datentypen auszuführen (mehr dazu später).

Beispiel: (andere Wrapper-Klassen funktionieren analog...) int i = 3; Integer j = new Integer( i ); // Die 3 in ein Objekt verpackt int k = j.intValue(); // Wieder auspacken... Übung:

Schauen Sie sich die Funktionsweise der Wrapper-Klassen in der API-Referenz an! ♦

♦

4.3 Die Klasse Stack

Die Klasse Stack stellt einen Stapelspeicher für Objekte zur Verfügung (Last in, first out). Stack s = new Stack(); // Leeren Stapel anlegen ... s.push( new Integer( 1 ) ); // auf Stapel packen s.push( "Die Zwei" ); ... String s = (String)( s.pop() ); // vom Stapel entfernen Object alsNaechstesKommt = s.peek(); // vorausschauen! ... if ( s.empty() ) System.out.println( "nix mehr da!" );



4.4 Die Klasse Vector

Die Klasse Vector ist eine nützliche Alternative zu einem Array. In einem Vektor können beliebige Objekte abgelegt werden, die Länge des Vektors ist dynamisch veränderbar.

♦

Beispiel: Vector namen = new Vector(); namen.addElement( "Helmut" ); namen.addElement( "Otto" ); namen.addElement( "Willi" ); namen.removeElementAt( 1 ); namen.insertElementAt( "Anton", 0 ); String name = (String)( namen.elementAt( 1 ) ); Konstruktoren für Vektoren: new Vector(); new Vector( int initialCapacity ); new Vector( int initialCapacity, int capacityIncrement ); Den Inhalt des Vektors verändern: void addElement( Object obj ); // obj Hinten anhängen void insertElementAt( Object obj, int index ); // einfügen void setElementAt( Object obj, int index ); // austauschen void removeAllElements(); // alles löschen void removeElementAt( int index ); // an index löschen boolean removeElement( Object obj ); // obj entfernen Auf Elemente zugreifen: Object elementAt( int index ); // Element an Indexposition Object firstElement(); // Erstes Element Object lastElement(); // Letztes Element Den Vektor durchsuchen: boolean contains( Object obj ); // Ist obj drin? int indexOf( Object obj ); // Suche vorwärts int indexOf( Object obj, int index ); // Suche ab index int lastIndexOf( Object obj ); // Suche rückwärts int lastIndexOf( Object obj, int index ); // rückw. ab index Länge eines Vektors: int size(); // Anzahl Elemente im Vektor boolean isEmpty(); // Ist der Vektor leer? void setSize( int newSize ); // Vektor 'zurechtschneiden'



4.5 Die Klasse Hashtable

Die Klasse Hashtable aus dem Paket java.util bietet die Funktionen einer Hashtabelle, in der Schlüssel auf Werte abgebildet werden. Um diese Abbildung zu ermöglichen, wird für jeden Schlüssel ein Hashcode benutzt.

♦

♦

♦

Als Schlüssel und Elemente der Hashtabelle können beliebige Objekte verwendet werden, die die Methoden equals und hashcode bereitstellen. Mit Hilfe von Wrapper-Klassen kann man auch primitive Datentypen benutzen. Beim Auffinden von Elementen anhand eines vorgegebenen Schlüssels wird dieser mit equals mit den Schlüsseln in der Tabelle verglichen, es wird also auf inhaltliche Gleichheit verglichen!

Hashtable h = new Hashtable( 10 ); // neue Tabelle anlegen, voraussichtlich 10 Werte Wichtige Methoden: Object put( Object key, Object value ); // Einen Wert unter einem bestimmten Schlüssel ablegen Object get( Object key ); // In der Tabelle Wert zu diesem Schlüssel suchen Object remove( Object key ); // Wert unter diesem Schlüssel entfernen boolean contains ( Object value ); // Wert vorhanden? boolean containsKey( Object key ); // Schlüssel vorhanden?



Beispiel: import java.util.Hashtable; public class Buchstabierer { protected Hashtable buchstaben; public Buchstabierer() { buchstaben = new Hashtable( 26 ); buchstaben.put( "a", "Anton" ); buchstaben.put( "b", "Berta" ); buchstaben.put( "c", "Cesar" ); // ... } public void buchstabiere( String s ) { s = s.toLowerCase(); for ( int i = 0; i < s.length(); i++ ) { String c = s.substring( i, i + 1 ); if ( buchstaben.containsKey( c ) ) System.out.print( buchstaben.get( c ) ); } System.out.println(); } public static void main( String[] args ) { Buchstabierer bsb = new Buchstabierer(); for( int i = 0; i < args.length; i++ ) bsb.buchstabiere( args[ i ] ); } } Aufruf: java Buchstabierer Hallo ein Test



4.6 Die Klassen Runtime und Process

Mit Hilfe der Klassen Runtime und Process lassen sich Kommandos aus Java heraus absetzen, z. B. um ein externes Programm zu starten:

♦

♦

Runtime dieLaufzeitUmgebung = Runtime.getRuntime(); // sowas nennt man "Singleton": Es gibt nur eine Instanz! Process p = dieLaufzeitUmgebung.exec( "arbeiten.bat" ); // Es gibt Varianten zum gleichzeitigen Setzen von // Umgebungsvariablen, Übergeben von Argumenten... p.waitFor(); // Wartet auf Beendigung p.destroy(); // beendet den Prozeß int i = p.exitValue(); // der zurückgegebene Exit-Code

Läuft ein Prozess, kann man auf seinen Eingabe-, Ausgabe- und Fehlerstrom zugreifen: InputStream is = p.getInputStream(); // Ausgabe von p InputStream es = p.getErrorStream(); // Fehler von p OutputStream os = p.getOutputStream(); // Eingabe an p



5. Konvertieren zwischen Datentypen und Objekten 5.1 Zwischen primitiven Datentypen konvertieren

Im Gegensatz zu anderen Sprachen führt Java in der Regel keine automatische Typkonvertierung durch.

♦

♦

♦

♦

♦

♦

Primitive Datentypen können durch Voranstellen von "(Datentyp)" konvertiert werden. Dieses Casting erzeugt einen neuen Wert, der ursprüngliche Wert wird nicht verändert! Casting von einem Datentyp zu einem anderen mit größerem Wertebereich (also z. B. von int nach long) ist nicht explizit nötig. Casting von einem Datentyp zu einem anderen mit kleinerem Wertebereich (also z. B. von double nach float) muß explizit erfolgen. Der Datentyp boolean kann nicht in andere Datentypen gecastet werden. Die int-Werte 0 und 1 können aber nach boolean gecastet werden. Da Casting eine sehr hohe Präzedenz hat, muß der zu castende Ausdruck geklammert werden, falls es sich nicht um eine einzelne Variable handelt.

Beispiel: int i = (int)( 38.5 / 10.7 );

♦

♦

♦

5.2 Zwischen Objekten konvertieren

Bei Casting zwischen Objekten müssen diese in einer Vererbungsbeziehung zueinander stehen. Casting von der Subklasse zur Superklasse ist nicht explizit nötig. Instanzen von Subklassen können überall dort verwendet werden, wo eine Instanz der Superklasse erwartet wird, d. h. Sie können z. B. einen String jeder Methode übergeben, die ein Object erwartet. Casting von der Superklasse zur Subklasse ist explizit durch Voranstellen von (Klassenname) nötig, da hier Information verloren gegangen ist.

Beispiel:

Vergleiche vorangegangene Beispiele zur Klasse Vector! ♦ 5.3 Objekte in Strings konvertieren • Viele Klassen besitzen eine Methode toString(), die eine String-Darstellung des

Objektes zurückgibt, z. B. die Wrapper-Klassen. Beispiel: Integer i = new Integer( 5 ); String s = i.toString();



5.4 Primitive Datentypen in Strings konvertieren

Die Klasse String besitzt die überladene Klassenmethode valueOf(), mit der die primitiven Datentypen boolean, double, float, int, long, char und char[]-Arrays in Strings konvertiert werden können.

♦

Beispiele: boolean b = true; String s = String.valueOf( b ); double d = 28.425; String t = String.valueOf( d ); 5.5 Strings in primitive Datentypen konvertieren

Die Wrapper-Klassen Integer und Long besitzen Klassenmethoden parseInt() bzw. parseLong(), mit deren Hilfe Strings in int- und long-Werte konvertiert werden können. Dabei kann auch eine Basis (z. B. 2, 10, 16) angegeben werden.

♦

♦ Die Wrapper-Klassen Boolean, Integer, Long, Float und Double besitzen Klassenmethoden valueOf(), mit deren Hilfe Strings in ein Objekt dieser Klasse und von dort aus in einen primitiven Datentyp konvertiert werden können.

Beispiel: String s = "4711"; int i = Integer.parseInt( s ); String t = "C000"; int j = Integer.parseInt( t, 16 ); String u = "100101"; int k = Integer.parseInt( u, 2 ); 5.6 Wrapper-Objekte in primitive Datentypen konvertieren

Alle Wrapper-Klassen besitzen Instanzmethoden, um sie zurück in die primitiven Datentypen zu konvertieren, die sie repräsentieren, z. B. booleanValue() in der Klasse Boolean, charValue() in der Klasse Character.

♦

♦ Die Wrapper-Klassen Integer, Long, Float und Double besitzen alle jeweils die vier Instanzmethoden intValue(), longValue(), floatValue() und doubleValue(), über die diese Objekte in die entsprechenden primitiven Datentypen konvertiert werden können.

Beispiel: String s = "153.92"; Double d = Double.valueOf( s ); double x = d.doubleValue(); float y = d.floatValue(); Hinweis:

Die numerischen Wrapper-Klassen besitzen außerdem die Konstanten MAX_VALUE, MIN_VALUE, NEGATIVE_INFINITY und POSITIVE_INFINITY zur Ermittlung des Wertebereiches der Primitivtypen bzw. Darstellung von + / - ∞.

♦



6. Laufzeitfehler behandeln mit Exceptions 6.1 Grundlegendes über Laufzeitfehler

Java bietet die Möglichkeit, nahezu alle auftretenden Laufzeitfehler abzufangen, zu behandeln, weiterzuleiten oder eigene Laufzeitfehler zu erzeugen. Laufzeitfehler, die nicht abgefangen werden, führen zum Abbruch des Programms oder zumindest (bei graphischen Benutzeroberflächen) zum Abbruch des aktuellen Threads.

♦

♦

♦

♦

♦

Laufzeitfehler sind in Java Instanzen der Klasse "Throwable" oder einer ihrer Unterklassen. Für jede Fehlerart gibt es eine spezielle Klasse. Bei Auftreten eines Fehlers erzeugt Java eine Instanz der jeweiligen Klasse. Dieses Objekt kann Informationen über den Fehler enthalten, z. B. den nicht gefundenen Dateinamen bei einer Instanz von "FileNotFoundException". Es gibt zwei Unterklassen von "Throwable": Die Klasse "Error" stellt schwerwiegende Fehler dar, die nicht abgefangen werden können. Die Klasse "Exception" stellt Laufzeitfehler dar, die man abfangen und behandeln kann. Die Klasse "Exception" besitzt wiederum viele Unterklassen, eine davon ist "RuntimeException". Instanzen von "RuntimeException" können, müssen aber nicht abgefangen werden, z. B. eine "ArithmeticException" bei einer möglichen Division durch Null. Instanzen von Klassen, die nicht Unterklassen von "RuntimeException" sind, müssen unbedingt abgefangen werden. Methodenaufrufe, die eine solche Exception eventuell auslösen, lassen sich nicht compilieren, wenn der aufrufende Code mögliche Laufzeitfehler nicht abfängt oder explizit weiterleitet.

6.2 Laufzeitfehler abfangen und behandeln

Zum Abfangen einer Exception werden Code-Teile, die eventuell eine Exception erzeugen, in einen try-Block eingebetten, an dessen Ende eine eventuell auftretende Exception in einem catch-Block abgefangen und behandelt werden kann.

Beispiel: public static void main( String[] args ) { String versuch = "Test"; try { versuch = args[ 0 ]; System.out.println( "Es hat funktioniert!" ); } catch( ArrayIndexOutOfBoundsException ex ) { System.out.println( "Ein Fehler ist aufgetreten." ); ex.printStackTrace(); // Zeige Position, an der der Fehler aufgetreten ist. System.out.println( ex.getClass().getName() ); System.out.println( ex.getMessage() ); } System.out.println( versuch ); }



Beachte:

Es können mehrere catch-Blöcke angegeben werden, um verschiedene Klassen von Exceptions abzufangen, oder nur eine Superklasse (Exception) wird abgefangen und dann mit instanceOf überprüft, um welche als Exception es sich handelt. So kann die Klassenhierarchie der Exception-Arten genutzt werden.

♦

try{ ... } catch( ArithmeticException ex ){ ... } catch( FileNotFoundException ex ){ ... } try{ ...} catch ( Exception ex ) { if ( ex instanceof ArithmeticException ) { ... } else if ( ex instanceof FileNotFoundException ) { ... } } Beispiel: try{ Thread.sleep( 500 ); /* Schlafe 500 ms */ } catch( InterruptedException ex ){} // Fehler ignorieren 6.3 Laufzeitfehler weiterleiten

Es gilt die catch-or-throw-Regel: Exceptions, die nicht RuntimeExceptions sind, müssen in der Methode, in der sie auftreten können, mit catch behandelt werden, oder die Methode hat eine entsprechende throws-Anweisung, die die Exception dann wiederum weitergibt, so daß sie weiter nach oben in der Aufrufhierarchie durchwandert. Dort muß sie wiederum behandelt oder weitergegeben (catch or throw) werden.

♦

Beispiel: public void a() throws IOException { FileInputStream fis = new FileInputStream( "test.xy" ); int i = fis.read(); System.out.println( i ); } public void b() throws IOException { a(); System.out.println( "Grüsse von b()!" ); } public void c() { try{ b(); } catch( IOException ex ) { System.out.println( "Da ging was schief." ); } }



6.4 Finally

Hinter dem catch- oder try- Teil kann auch noch ein finally-Teil angegeben werden, der immer ausgeführt wird, egal, ob der try-Block normal beendet wurde oder eine Ausnahme erzeugt wurde:

♦

♦

FileInputStream fis; try { fis = new FileInputStream( "test" ); int i = fis.read(); System.out.println( i ); } finally { if( fis != null ) fis.close(); } 6.5 Eigene Exceptions definieren

Eigene Exceptions lassen sich durch Ableiten von der Klasse Exception (für unbedingt abzufangende Fehler) oder RuntimeException (für nicht zwingend abzufangende Fehler) definieren.

Beispiel: public class UnsinnException extends RuntimeException { public UnsinnException( String nachricht ) { super( nachricht ); } } public class Textverarbeitung { public static void verarbeite( String s ) { if ( s.toLowerCase().indexOf( "unsinn" ) != -1 ) throw new UnsinnException ( "Unsinn wird nicht verarbeitet!" ); System.out.println( s.toUpperCase() ); } public static void main( String[] args ) { for( int i = 0; i < args.length; i++ ) { try{ verarbeite( args[ i ] ); } catch ( UnsinnException ex ) { System.out.println( "Fehler bei " + args[ i ] + ": " + ex.getMessage() ); } } } }




V. Applets, Grafik- und Soundausgabe, Ereignisse 85

V. Applets, Grafik- und Soundausgabe, Ereignisse



1. Applets

Es gilt das "Sandkastenprinzip" bei heruntergeladenen Java-Applets: Das Applet kann in einem kontrollierten 'Sandkasten' spielen, der Java Virtual Machine des Browsers, darf diesen aber nicht 'verlassen'.

♦

♦ ♦ ♦ ♦

♦

Was aus dem Netz heruntergeladene Applets nicht dürfen:

Zugriffe auf das Dateisystem des Clients (Schreiben, Lesen von Dateien) Kommunikation mit beliebigen Servern im Netz Programme starten oder Kommandos ausführen Zugriff z. B. auf die Windows Registry

Was Applets dürfen:

Kommunikation mit dem Heimat-Server über das Netz (z. B. über CGI-Aufrufe, FTP, HTTP, POP3, SMNP, SNMP, ...)

Beachte:

In einigen älteren Browsern haben Applets, die lokal von der Festplatte des Clients geladen werden, mehr Rechte als solche, die über das Netz geladen werden.

♦

♦

♦ ♦ ♦ ♦

Bei Verwendung der Microsoft-eigenen Java-Erweiterungen für ActiveX kann ein Java-Applet auf alle Windows-Ressourcen zugreifen.

Was Applikationen dürfen: Alles, außer direkt auf Hardware zugreifen!

Kommunikation mit beliebigen Servern über das Netz Neue Prozesse erstellen, Programme starten, Kommandos ausführen Native Code ausführen (Java Native Interface): C-Module einbinden Zugriff auf das Dateisystem

Hinweis:

Der Sprachumfang des JDK 1.1 und 1.2 bietet weiterführende Konzepte, z .B das Signieren von Applets. Digital signierten Applets kann man individuelle Rechte gewähren, z. B. auch den Zugriff auf das lokale Dateisystem des Clients. Leider verwenden Netscape, Microsoft und Sun hier jeweils unterschiedliche Signierungstechniken und APIs, so daß man je nach Browser noch unterschiedliche Verfahren anwenden muß. Die in der Praxis sinnvollste Lösung ist hier die Verwendung des Java Plug-ins.

♦



1.1 Grundgerüst eines Applets import java.applet.Applet; import java.awt.Graphics; public class MyApplet extends Applet { public void init() { // Wird aufgerufen, wenn das Applet geladen wurde // Typische Aufgaben hier z. B. Parameter abfragen, // Grafik- und Sounddateien laden, ... } public void start() { // Wird aufgerufen nach init() oder wenn der Benutzer // zu dieser Webseite zurückkehrt // Aufgaben z. B. Netzverbindung aufbauen, ... } public void stop() { // Wird aufgerufen, wenn der Benutzer diese Webseite // verläßt. // Aufgaben z. B. Netzverbindung beenden, ... } public void destroy() { // Wird aufgerufen, wenn das Applet zerstört wird, // in der Regel bei Beenden des Browsers. // Wird nur selten angewandt. } public void paint( Graphics g ) { // Applet-Bereich auf der HTML-Seite zeichnen } }



1.2 Aufruf eines Applets innerhalb einer Webseite <HTML> <HEAD> <TITLE>Applet-Testseite</TITLE> </HEAD> <BODY> Hier kommt das Applet:<P> <APPLET CODE = "MyApplet.class" Name der Klassendatei CODEBASE = "foo/bar/classes" Verzeichnis mit class-Dateien ARCHIVE = "MyAppletClasses.jar" Archivdatei mit *.class WIDTH = 300 Breite auf der Seite HEIGHT = 200 Höhe auf der Seite HSPACE = 10 Horizontaler Abstand um das Applet VSPACE = 10 Vertikaler Abstand um das Applet ALIGN = LEFT Ausrichtung zum umgebenden Text,

wie beim <IMG>-Tag in HTML

> <PARAM NAME="user" VALUE="John Doe" > Parameter <PARAM NAME="font" VALUE="TimesRoman" > <PARAM NAME="size" VALUE="36" > Dieser Text erscheint, wenn der Browser kein Java versteht. </APPLET> <P>Hier kommt der Rest der Seite. </BODY> </HTML>

Parameter können über das <PARAM>-Tag zwischen <APPLET> und </APPLET> übergeben werden. Beachte, daß Value immer eine Zeichenkette ist und im Gegensatz zu HTML allgemein die Groß-/Kleinschreibung beim Parameternamen wichtig ist!

♦



1.3 Aufruf-Parameter aus der Webseite auslesen import java.applet.*; import java.awt.*; public class MyApplet extends Applet { protected Font f; protected String name; public void init() { // Parameter auslesen String userName = getParameter( "user" ); String fontName = getParameter( "font" ); String fontSize = getParameter( "size" ); // Wurden alle Parameter angegeben? // Ansonsten Standardwerte nehmen: if ( userName == null ) userName = "Nobody"; if ( fontName == null ) fontName = "Courier"; if ( fontSize == null ) fontSize = "12"; // fontSize von String nach int konvertieren: int fsize = Integer.parseInt( fontSize ); // Zeichensatz-Objekt erzeugen, Instanzvariablen setzen: f = new Font( fontName, Font.BOLD, fsize ); name = userName; } public void paint( Graphics g ) { g.setFont( f ); g.setColor( Color.blue ); g.drawString( "Hallo " + name + "!", 10, 50 ); } }



2. Zeichnen mit der Graphics-Klasse

Das Graphics-Objekt repräsentiert den Zeichenbereich eines Applets. ♦ ♦ ♦

♦

Im Koordinatensystem der Graphics-Klasse liegt der Punkt (0,0) oben links! Mit der Graphics-Klasse kann man folgende einfache Formen zeichnen:

2.1 Farben setzen und Text ausgeben public void paint( Graphics g ) { this.setBackground( Color.red ); Font f = new Font( "TimesRoman", Font.BOLD, 36 ); g.setFont( f ); g.setColor( Color.blue ); g.drawString( "Hallo!", 10, g.setColor( Color.yellow );

50 );

g.drawString( "Wie geht's?", 10, 100 ); }

Die Klasse java.awt.Color bietet weitreichende Methoden zum Umgang mit Farbwerten. Man kann z. B. eine beliebige Farbe durch Angabe ihrer Rot/Grün/Blau-Anteile erzeugen:

Color c = new Color( 100, 80, 140 ); g.setColor( c );



2.2 Linien und Rechtecke zeichnen g.drawLine( 10, 10, 50, 50 ); // Linie von (10,10) nach (50,50) g.drawRect( 5, 10, 45, 50 ); // Rechteck oben links = (5,10) mit Breite 45 u. Höhe 50 g.fillRect( 5, 10, 45, 50 ); // Gefülltes Rechteck g.drawRoundRect( 5, 10, 45, 50, 10, 10 ); // mit gerundeten Ecken von 10*10 Pixeln im Quadrat g.fillRoundRect( 5, 10, 45, 50, 10, 10 ); // Gefülltes, gerundetes Rechteck g.draw3DRect( 10, 10, 30, 30, true ); // Schattiertes Rechteck (3D-Look), Rechteck erhaben g.fill3DRect( 10, 10, 30, 30, false ); // Schattiertes Rechteck (3D-Look), Rechteck vertieft Hinweis: Nicht gefüllte Rechtecke sind in Java immer 1 Pixel breiter und höher als gefüllte Rechtecke bei Verwendung der gleichen Parameter! 2.3 Polygone (Vielecke) zeichnen int x[] = { 10, 20, 15, 30, 45, 70 }; int y[] = { 10, 15, 30, 40, 30, 40 }; g.drawPolygon( x, y, x.length ); g.fillPolygon( x, y, x.length ); Polygon p = new Polygon( x, y, x.length ); p.addPoint( 10, 10 ); ... g.drawPolygon( p ); g.fillPolygon( p ); 2.4 Ovale, Kreise und Ellipsen zeichnen

Kreise und Ellipsen werden durch das Rechteck definiert, das sie einschließt. ♦ g.drawOval( 10, 10, 30, 50 ); // Ellipse, die genau eingeschlossen wird durch das // Rechteck, das bei drawRect() mit den gleichen // Parametern entstehen würde g.fillOval( 25, 25, 40, 40 ); // Gefülltes Oval, sonst wie oben // Ist ein Kreis, da Breite = Höhe = 40 // Mitte ist demnach bei (45,45) und Radius = 20



2.5 Kreis- und Ellipsenbögen zeichnen

Die Parameter für Bögen lassen sich am einfachsten bestimmen, in dem man sich den Bogen zunächst als vollendete Ellipse vorstellt:

♦

♦ ♦ ♦ ♦

g.drawOval( 25, 25, 40, 40 ); // Kreis aus dem obigen Beispiel

Anschließend wird angegeben, ab welchem Gradwert der Bogen zu sehen sein soll: 0 Grad = 3 Uhr = Osten, 90 Grad = 12 Uhr = Norden usw. Außerdem muß angegeben werden, wieviel Grad der Bogen einnehmen soll: z. B. 180 Grad für eine halbe "Umrundung" gegen den Uhrzeigersinn, -90 Grad für ein Viertel im Uhrzeigersinn

g.drawArc( 25, 25, 40, 40, 90, 90 ); // Der Teilbogen des obigen Kreises, der bei 12 Uhr beginnt // und bei 9 Uhr endet, also das linke obere Viertel Hinweis:

Bei all diesen Methoden kann die Liniendicke nicht bestimmt werden! ♦



3. Arbeiten mit Fonts 3.1 Font-Objekte erzeugen

Zur Textausgabe in Applets lassen sich verschiedene Zeichensätze verwenden. Hierzu dient die Klasse Font.

♦

♦

♦

Der Font-Konstruktor erwartet als Parameter den Fontnamen, den Stil und die Schriftgröße in Punkt:

Font f = new Font( "Serif", Font.BOLD, 12 );

Fontstile sind int-Werte, die als Konstanten in der Klasse Font definiert sind, z .B. Font.BOLD, Font.PLAIN, Font.ITALIC. Diese lassen sich kombinieren:

Font f = new Font( "Monospaced", Font.BOLD + Font.ITALIC, 8 ); Beachte:

Die Menge der unterstützten Zeichensätze ist systemabhängig! Um herauszufinden, welche Fonts vom Laufzeitsystem unterstützt werden, existiert die Methode getFontList() in der Klasse Toolkit des Paketes java.awt:

♦

♦

♦

String[] fontnames = Toolkit.getDefaultToolkit().getFontList();

In allen Java-Systemen sollten die Fonts "Serif", "SansSerif" und "Monospaced" unterstützt sein. Die Java-Laufzeitumgebung bildet diese symbolischen Fontnamen auf Systemfonts ab, unter Windows z. B. auf die True-Type-Schriften "Times New Roman", "Arial" und "Courier". Im JDK 1.0 hießen die Standardfonts (statt obiger Bezeichner) "TimesRoman", "Helvetica" und "Courier".



3.2 Zeichensätze verwenden: Font f1 = new Font( "TimesRoman", Font.BOLD, 36 ); g.setFont( f1 ); // g ist eine Graphics-Instanz g.drawString( "HRZ", 20, 20 ); Font f2 = g.getFont(); // Gerade aktiven Font ermitteln String name = f2.getName(); int size = f2.getSize(); int style = f2.getStyle(); // 0 = PLAIN, 1 = BOLD, // 2 = ITALIC, 3 = 1 + 2 :-) boolean b1 = f2.isPlain(); boolean b2 = f2.isBold(); boolean b3 = f2.isItalic(); 3.3 Größeninformationen über Zeichensätze

Die Klasse FontMetrics enthält Größeninformationen über einen Font, z. B. über die Maße der Zeichen in einem Font. Damit läßt sich z. B. ermitteln, welche Breite ein Text mit einem bestimmten Font benötigt:

♦

♦

// g ist eine Graphics-Instanz, z. B. aus paint( Graphics g ); // f2 ist eine Font-Instanz, z. B. erzeugt mit new Font(...) int breite = g.getFontMetrics( f2 ).stringWidth( "Hallo" );

Die wichtigsten Methoden der Klasse FontMetrics: public int charWidth( char c ); // Breite eines Zeichens public int StringWidth( String s ); // Breite eines Strings public int getAscent(); // Oberlänge, vgl. Buchstabe 'H' public int getDescent(); // Unterlänge, vgl. Buchstabe 'j' public int getHeight(); // Gesamte Höhe public int getLeading(); // Zeilenabstand (ohne Font-Höhe)



4. Verwenden von Bilddateien

Java ist in der Lage, Grafikdateien vom Typ "GIF" und "JPEG" (die auch von HTML unterstützten Grafiktypen) direkt darzustellen. Diese werden durch die Klasse Image realisiert.

♦

♦

♦

♦ ♦

♦

4.1 Laden von Images

Die Klasse Applet besitzt eine Methode, um ein Image aus dem Netz nachzuladen. Ihr wird eine Instanz der Klasse URL übergeben, das die URL der Grafikdatei enthält:

import java.net.URL; import java.awt.*; import java.applet.*; ... URL url1 = new URL("http://www.irgendwo.com/bild1.gif" ); Image bild1 = this.getImage( url1 );

Um die Position des Bildes auf dem Server relativ zur Position des Applets (d. h. der class-Datei) anzugeben, existiert eine Variante von getImage, die eine URL und einen dazu relativen Pfadnamen erwartet:

// Position der Bilddatei relativ zur aufrufenden HTML-Seite URL url2 = this.getDocumentBase(); Image bild2 = this.getImage( url2, "bild2.jpg" ); // Position relativ zum Verzeichnis der class-Datei(en) URL url3 = this.getCodeBase(); Image bild3 = this.getImage( url3, "bilder/bild3.gif" );

Wird ein Bild nicht gefunden, liefert getImage() den Wert null zurück. In Java-Applications kann man Images über die Klasse Toolkit laden:

URL url4 = new URL( "http://www.irgendwo.de/bild.gif" ); Image bild4 = Toolkit.getImage( url4 ); Image bild5 = Toolkit.getImage( "xy.gif" );

Ab JDK 1.1 kann man Images als Resource laden, d.h. sie werden wie die Klassen im Klassenpfad gesucht und automatisch geladen. Das geht im Applet in etwa wie folgt:

URL url = getClass().getResource( "companylogo.gif" ); Image i = createImage( (ImageProducer) url.getContent() ); 4.2 Breite und Höhe eines Bildes bestimmen int bx = bild3.getWidth( this ); // Breite int by = bild3.getHeight( this ); // Höhe



4.3 Anzeigen von Images

Die Klasse Graphics besitzt überladene Methoden drawImage(), um das Bild anzuzeigen.

♦

♦

♦

♦

♦

Die drawImage-Methoden liefern einen boolean-Wert zurück, der angibt, ob alle Bits des Bildes verfügbar waren. Der letzte Parameter von drawImage ist wieder der ImageObserver.

boolean ok; ok = g.drawImage( bild1, 5, 5, this ); // Bild mit oberer linker Ecke bei (5,5) ausgeben ok = g.drawImage( bild2, 5, 5, 100, 120, this ); // Bild auf die Größe von 100 * 120 Pixeln skalieren

GIF-Bilder erlauben es, sie so abzuspeichern, daß Punkte mit einer bestimmten Farbe als transparent angesehen werden, d. h. die Grafik ist an diesen Stellen "durchsichtig". Die obigen Methoden geben diese Bildpunkte ebenfalls transparent aus, d. h. schon in der Methode gezeichnete Dinge werden durch diese Bildpunkte nicht verändert. Alternativ kann man die transparenten Bildpunkte durch eine Farbe einfärben:

ok = g.drawImage( bild1, 5, 5, Color.blue, this ); // Transparente Punkte blau darstellen ok = g.drawImage( bild2, 5, 5, 100, 120, Color.blue, this ); // Transparente Punkte blau darstellen und skalieren 4.4 Ladevorgänge überwachen mit der Klasse MediaTracker import java.applet.*; import java.awt.*; import java.net.*; public class ImageApplet extends Applet { protected Image bild; public void init() { URL dir = this.getDocumentBase(); bild = this.getImage( dir, "bild.jpg" ); MediaTracker mt = new MediaTracker( this ); mt.addImage( bild, 0 ); try{ mt.waitForAll(); } catch( Exception ex ) { System.out.println( "Fehler beim Laden des Bildes!"); } } public void paint( Graphics g ) { if( bild != null ) g.drawImage( bild, 0, 0, this ); } }



5. Ausgabe von Audiodateien

Java unterstützt das direkte Abspielen von Audiodateien, die im AU-Format vorliegen. Dies ist ein Sun-eigenes Format, dessen Dateien zum Preis einer geringeren Tonqualität relativ klein sind.

♦

♦

♦

♦

Im Internet findet man Konvertierungsprogramme, um z. B. WAV-Dateien in das AU-Format umzuwandeln.

5.1 Direktes Laden und Abspielen von Audiodateien

Über die Methode play() der Klasse Applet lassen sich analog zum Vorgehen bei getImage() AU-Dateien herunterladen und unmittelbar abspielen:

URL url1 = new URL( "http://www.irgendo.com/ton.au" ); this.play( url1); URL url2 = this.getDocumentBase(); this.play( url1, "sounds/spacemusic.au" ); 5.2 AudioClip-Instanzen erzeugen und abspielen

Will man den Sound wiederholt verwenden, kann man analog zur Klasse Image Audiodateien als Instanzen der Schnittstelle AudioClip erzeugen:

URL url3 = this.getDocumentBase(); AudioClip sound = this.getAudioClip( url3, "spacemusic.au" ); sound.play(); // einmaliges Abspielen sound.loop(); // wiederholtes Abspielen sound.stop(); // Abspielen stoppen Beispiel: Hintergrundmusik für die Webseite import java.applet.*; import java.net.*; public class AudioApplet extends Applet { protected AudioClip sound; public void init() { URL dir = this.getDocumentBase(); sound = this.getAudioClip( dir, "spacemusic.au" ); } public void start() { sound.loop(); } public void stop() { sound.stop(); } }



6. Auf Ereignisse reagieren

Um eine graphische Oberfläche realisieren zu können, muß das System dem Programm eine Mitteilung senden, sobald bestimmte Ereignisse auftreten (Mausklick, Taste losgelassen, ...).

♦

♦

♦

♦

♦

In Java dient dazu der Event-Mechanismus, der durch die Klassen im Paket java.awt.event realisiert wird. Den verschiedenen Ereignissen entsprechen Klassen in diesem Paket, deren gemeinsame Superklasse die Klasse AWTEvent ist und die in einer Hierarchie zueinander stehen. Komponenten, die Ereignisse auslösen (also Event-Objekte erzeugen) werden Ereignisquellen genannt. Ein Button löst z. B. einen ActionEvent aus, wenn er gedrückt wird, eine Mausbewegung in einer Komponente löst einen MouseEvent aus. Man kann nun auf Ereignisse reagieren, indem man für bestimmte Ereignisse Ereignisempfänger (Event Listeners) bei der Komponente anmeldet. Ereignisempfänger sind Klassen, die ein zu einem Ereignistyp passendes Interface implementieren, dessen Methoden das System dann bei Auftreten des Ereignisses aufruft. Diese Listener-Interfaces sind Subklassen von EventListener. Dieses Modell wird ab JDK 1.1 verwendet und wird Delegation Event Model genannt, da es die Möglichkeit bietet, die Ereignisverarbeitung einer Komponenten beliebige andere Klassen zu delegieren.

Beispiele anhand von Mausereignissen:

Komponenten, z. B. Applets, lösen MouseEvents aus, wenn ein Mausereignis auftritt. Um Mausereignisse zu verarbeiten, registriert man bei der Komponente MouseListener oder MouseMotionListener, das sind Klassen, die das entsprechende Interface implementieren. Tritt das Ereignis auf, wird die entsprechende Methode der registrierten Listener aufgerufen und ihr eine Instanz der Klasse MouseEvent übergeben, die Details über das Ereignis enthält.

♦

♦ Die Menge der registrierten Listener kann für eine Komponente über entsprechende add/remove-Anweisungen verändert werden. Es ist also auch möglich, mehr als einen Listener für ein bestimmtes Ereignis zu registrieren.



Bei einem Mausereignis ruft die Ereignisquelle z. B. die Methode mouseClicked() des MouseListeners auf:

♦

public void mouseClicked( MouseEvent e ) { int x = e.getX(); // Wo? int y = e.getY(); Point p = e.getPoint(); int clickCount = e.getClickCount(); // Doppelklick? int mods = e.getModifiers(); // Welche Maustaste? int buttonNr; if( ( mods & InputEvent.BUTTON3_MASK) != 0 ) buttonNr = 3; else if( ( mods & InputEvent.BUTTON2_MASK) != 0 ) buttonNr = 2; else if( ( mods & InputEvent.BUTTON1_MASK) != 0 ) buttonNr = 1; // Weitere Codezeilen, um auf das Ereignis zu reagieren... }



6.1 Die Komponente 'hört sich selbst zu' import java.awt.*; import java.awt.event.*; import java.applet.*; public class MausApplet extends Applet implements MouseListener, MouseMotionListener { public void init() { this.addMouseListener( this ); this.addMouseMotionListener( this ); } // Methoden des MouseListener Interfaces: public void mouseClicked( MouseEvent e ) { int x = e.getX(); int y = e.getY(); Graphics g = getGraphics(); g.drawOval( x - 2, y - 2, 4, 4 ); g.dispose(); } public void mousePressed( MouseEvent e ){} public void mouseReleased( MouseEvent e ){} public void mouseEntered( MouseEvent e ){} public void mouseExited( MouseEvent e ){} // Methoden des MouseMotionListener Interfaces: public void mouseDragged( MouseEvent e ){} public void mouseMoved( MouseEvent e ){} }



6.2 Eine andere Klasse hört zu: import java.awt.*; import java.awt.event.*; import java.applet.*; public class MausApplet extends Applet { public void init() { MouseListener ml = new MausLauscher(); this.addMouseListener( ml ); } } class MausLauscher implements MouseListener { ... // Methoden des MouseListener Interfaces: public void mousePressed( MouseEvent e ){} public void mouseReleased( MouseEvent e ){} ... } 6.3 Arbeiten mit Adapter-Klassen:

Da Listener Interfaces sind, ist man gezwungen, alle Methoden des Interfaces zu implementieren, auch wenn wan vielleicht nur einige Methoden benötigt und nicht auf alle Ereignisse reagieren will.

♦

♦ Daher stellt Java sogenannte Adapter-Klassen für die Listener zur Verfügung, die mehr als eine Methode anbieten. Diese Adapter-Klassen besitzen alle Methoden des entsprechenden Interfaces, die aber einfach nichts tun, also leer sind. Durch Ableiten einer Klasse von einem Adapter kann man die leeren Methoden so einfach erben, statt sie selbst noch einmal aufführen zu müssen:

class MausLauscher extends MouseAdapter // bzw. MouseMotionAdapter bei Bedarf { // Überschreibe das leere mousePressed von MouseAdapter public void mousePressed( MouseEvent e ) { ... } // Der Rest wird geerbt. }



6.4 Arbeiten mit Inner Classes

Ab JDK 1.1 hat man die Möglichkeit, eine Klasse innerhalb einer anderen Klasse zu definieren (Inner Class). Diese Klasse ist dann nur innerhalb der definierenden Klasse benutzbar und daher lokal.

♦

♦

♦

Instanzen einer Inner Class haben Zugriff auf die Methoden und Variablen der Klasse, der sie gehören, bzw. des Blockes, in dem sie definiert sind. Dieses Konstrukt wird sehr oft wie folgt zur Ereignisverarbeitung verwendet:

import java.awt.*; import java.awt.event.*; import java.applet.*; public class MausApplet extends Applet { public void init() { this.addMouseListener( new LokalerMausLauscher() ); } class LokalerMausLauscher extends MouseAdapter { public void mousePressed( MouseEvent e ) { int x = e.getX(); int y = e.getY(); Graphics g = getGraphics(); g.fillRect( x, y, 2, 2 ); g.dispose(); } } }



6.5 Anonyme innere Klassen

Eine Variante lokaler Klassen sind anonyme Klassen. Diese Klassen werden innerhalb einer Anweisung definiert, in einer Kombination aus new, der Angabe einer Oberklasse und der Definition der Variablen und Methoden der Klasse. Das sieht dann etwa wie folgt aus:

♦

import java.awt.*; import java.awt.event.*; import java.applet.*; public class MausApplet extends Applet { public void init() { this.addMouseListener( new MouseAdapter() // anonyme Subklasse von MouseAdapter { public void mousePressed( MouseEvent e ) { int x = e.getX(); int y = e.getY(); Graphics g = getGraphics(); g.fillRect( x, y, 2, 2 ); g.dispose(); } } ); // Ende Aufruf addMouseListener } }



6.6 Auf Tastaturereignisse reagieren

Tastaturereignisse lösen in einer Komponente einen KeyEvent aus, wenn diese den Eingabefocus besitzt.

♦

♦

♦ ♦

♦

♦

♦

♦

Entsprechend existiert ein KeyAdapter, Methoden addKeyListener und removeKeyListener und ein KeyListener-Interface, das die folgenden Methoden besitzt:

void keyTyped ( KeyEvent e ); // UniCode-Taste getippt void keyPressed ( KeyEvent e ); // Taste gedrückt void keyReleased( KeyEvent e ); // Taste losgelassen

Eine Instanz von KeyEvent besitzt die folgenden Methoden: Jeder Taste ist ein Tastencode zugeordnet:

int code = e.getKeyCode(); // Tastencode if( code = KeyEvent.VK_F1 ) System.out.println( "You pressed F1, need some help?" );

Die statische Methode getKeyText liefert die Beschriftung der Taste: String label = KeyEvent.getKeyText( code ); // label = "F1"

Die statische Methode getKeyModifiersText liefert die Modifier-Label: String mods = KeyEvent.getKeyModifiersText( code ); // mods = "Ctrl+Shift" etc.

Die Methode getKeyChar liefert das getippte Zeichen: if( code != KeyEvent.CHAR_UNDEFINED ) char c = e.getKeyChar(); // UniCode-Zeichen der Taste 6.6.1 Die Klasse InputEvent

Die Klasse InputEvent ist die gemeinsame Basisklasse von MouseEvent und KeyEvent und besitzt noch einige weitere Methoden, die sich also sowohl bei MouseEvents als auch bei KeyEvents abfragen lassen:

boolean isShiftDown(); // true, falls Shift gedrückt war boolean isAltDown(); // true, falls Alt gedrückt war boolean isControlDown(); // true, falls CTRL gedrückt war boolean isMetaDown(); // true, falls Meta gedrückt war


VI. Graphische Benutzeroberflächen mit dem AWT 105

VI. Graphische Benutzeroberflächen mit dem AWT



1. Grundlagen graphischer Oberflächen ♦

♦

♦

♦

♦

♦

♦

♦

♦

Graphische Benutzeroberflächen können in Java mit Hilfe des Paketes java.awt erzeugt werden. Dieses Paket beinhaltet das Abstract Windowing Toolkit, das es ermöglicht, auf Elemente wie z. B. Buttons oder Checkboxes systemunabhängig zuzugreifen. Dies wird ermöglicht, indem für jedes Element einer Oberfläche (Fenster, Knopf, ...) eine sie abbildende Klasse existiert, die durch das Laufzeitsystem implementiert werden muß. Dies ist Aufgabe der Schnittstellensammlung im Paket java.awt.peer. Die Elemente der Oberfläche sehen daher immer so aus, wie sie in der Regel auch auf dem jeweiligen System erscheinen, abhängig davon, wo das Java-Programm ausgeführt wird. Sowohl Applets, als auch Applications können eine graphische Oberfläche besitzen, wobei Applets AWT-Grundelemente direkt im Appletbereich positionieren können, während Applications dazu erst ein Fenster erstellen müssen.

1.1 Die Bausteine des AWT Die Bausteine des AWT kann man in vier Kategorien aufteilen:

Einfache Komponenten, wie z. B. Buttons, Checkboxes und Labels, mit deren Hilfe der Benutzer letztendlich das Programm bedient Container, wie z. B. Fenster , Panels und Applets, die die Aufgabe haben, die Komponenten in sich aufzunehmen. LayoutManager, die für die Ausrichtung und Anordnung von Komponenten in einem ihnen zugeordneten Container verantwortlich sind. Events, die von Komponenten erzeugt werden, wenn bestimmte Ereignisse wie z. B. das Drücken eines Buttons auftreten, und durch entsprechende EventListener verarbeitet werden können.

Fast alle Elemente des AWT sind direkte oder indirekte Subklassen der abstrakten Klasse Component. Diese Klasse besitzt Methoden, die an jede Subklasse vererbt werden, z. B. die Funktionalität, Maus- und Tastaturereignisse auszulösen und angezeigt oder verborgen zu werden. Hier ein Ausschnitt aus der Klassenhierarchie:



1.2 Arbeiten mit einfachen Komponenten 1.2.1 Die Klasse Label

Label dienen der Beschriftung von Elementen der Oberfläche, z. B. zur Beschriftung eines Texteingabefeldes:

♦

♦

♦

Label l1 = new Label(); // Leere BeschLabel l2 = new Label( "ArtikelNr:" );

riftung (Platzhalter)

Label l3 = new Label( "ArtikelNr:", Label.RIGHT ); // Mit Ausrichtung: LEFT, RIGHT, CENTER als int-Konstante String t = l1.getText(); // Beschriftung holen l1.setText( "Eingabe:" ); // Beschriftung setzen int i = l1.getAlignment(); // Ausrichtung holen l1.setAlignment( Label.CENTER ); // Ausrichtung setzen 1.2.2 Die Klasse Button

Buttons realisieren Knöpfe, die gedrückt bzw. angeklickt werden können und dabei ein entsprechendes Ereignis auslösen:

Button b = new Button( "Abbrechen" ); String t = b.getLabel(); // Beschriftung holen b.setLabel( "Cancel" ); // Beschriftung setzen 1.2.3 Die Klasse Checkbox

Checkboxes sind Schalter-Felder, die durch Anklicken aktiviert oder deaktiviert werden können und eine eigene Beschriftung besitzen können:

Checkbox c1 = new Checkbox(); // Unbeschriftet Checkbox c2 = new Checkbox( "mit Mayo, bitte!" ); String t = c1.getLabel(); // Beschriftung holen c1.setLabel( "Mit Ketchup" ); // Beschriftung setzen boolean angekreuzt = c1.getState(); // Status holen c1.setState( true ); // Status setzen



1.3 Arbeiten mit Containern

Container-Instanzen haben die Aufgabe, Elemente der Oberfläche, wie z. B. Buttons in sich aufzunehmen.

♦

♦

♦

♦

♦

♦

♦

Container ist eine abstrakte Klasse. Entsprechend den verschiedenen Arten von Containern existieren die Subklassen Panel, ScrollPane (seit JDK 1.1) und Window. Die Klasse Window ist die Superklasse für Container, die auf dem Bildschirm bewegbar sind und in einem eigenen Fenster dargestellt werden. Es existieren die Subklassen Frame und Dialog. Die Klasse ScrollPane ist ein besonderer Container, der die in ihm enthaltene Komponente automatisch mit Scrollbalken versieht, um den sichtbaren Bereich der Komponente, z. B. eines Bildes, zu verändern. Die Klasse Panel ist ein Container, der im Gegensatz zu einem Window fest an einer bestimmten Position der Oberfläche fixiert ist. Da ein Container auch wie die einfachen Komponenten eine Subklasse von Component ist, lassen sich Panels und ScrollPanes ineinander verschachteln, was vielfältige Layout-Möglichkeiten bietet. Da jedes Panel seinen eigenen Layout-Manager besitzt, lassen sich so komplexe Anordnungen realisieren. Außerdem kann man durch Vererbung eigene Panel-Subklassen erzeugen und seine Oberflächen damit aus wiederverwendbaren Teilen zusammensetzen (Beispiele folgen). Die Klasse Applet ist eine Subklasse von Panel. Daher ist jedes Applet auch gleichzeitig ein Container, so daß sich in einem Applet auch AWT-Komponenten anordnen lassen. Applets besitzten gegenüber normalen Panels nur die bereits kennengelernten zusätzlichen Eigenschaften, wie z. B. mit dem Browser interagieren zu können( init(), start(), stop() usw.). Über die Methoden add() und remove() lassen sich Komponenten zu einem Container hinzufügen bzw. entfernen, so daß man auch dynamisch die Bestandteile der Oberfläche verändern kann.

Beispiel: public class GUIApplet extends Applet { protected Button b; protected Checkbox c; public void init() { b = new Button( "Hit Me!" ); c = new Checkbox( "Diesen Unsinn nicht mehr anzeigen" ); add( b ); add( c ); } } Hinweis:

Das Positionieren der Elemente ist Aufgabe eines sog. Layout-Managers. Mehr dazu später!

♦



1.4 Auf Ereignisse in der Oberfläche reagieren 1.4.1 Auf Buttons reagieren

Wenn ein Button angeklickt wird, wird ein ActionEvent erzeugt, den ein registrierter ActionListener in einer Methode actionPerformed() als Parameter erhält.

♦

public class Buttons extends Applet implements ActionListener { protected Button bBlau, bRot; public void init() { bBlau = new Button( "Blau" ); bRot = new Button( "Rot" ); add( bBlau ); add( bRot ); bBlau.addActionListener( this ); bRot .addActionListener( this ); } public void actionPerformed( ActionEvent e ) { Graphics g = getGraphics(); g.setColor( ( e.getSource() == bBlau ? Color.blue : Color.red ) ); g.drawRect( 0, 0, 100, 100 ); g.dispose(); } } 1.4.2 Auf Checkboxes unmittelbar reagieren public class Ankreuzen extends Applet implements ItemListener { protected Checkbox c; public void init() { c = new Checkbox( "Diesen Unsinn nicht mehr anzeigen" ); c.addItemListener( this ); add( c ); } public void itemStateChanged( ItemEvent e ) { System.out.println( "Zustand von c hat sich geändert" ); } }



1.5 Arbeiten mit Texteingabe-Komponenten 1.5.1 Die Klasse TextField

Diese Klasse stellt ein einzeiliges Eingabefeld für Text zur Verfügung. ♦ ♦

♦

Es ist möglich, statt der Eingabe ein anderes Zeichen als Echo auszugeben (sinnvoll bei Feldern, die z. B. Passwörter abfragen). Auch der Zugriff auf den markierten Teil der Eingabe ist möglich.

TextField anlegen TextField tname = new TextField(); // Leer TextField tname = new TextField( 20 ); // Breite 20 TextField tname = new TextField( "Willi" ); // Mit Vorgabe TextField tname = new TextField( "Willi", 20 ); Echo-Zeichen setzen und abfragen TextField tpasswd = new TextField( 20 ); tpasswd.setEchoChar( '*' ); char c; if ( tpasswd.echoCharIsSet() ) c = tpasswd.getEchoChar(); Text abfragen und setzen String name = tname.getText(); tname.setText( "Hallo Welt!" ); Markierten Textteil abfragen und Markierungsbereich setzen String markiert = tname.getSelectedText(); int von = tname.getSelectionStart(); int bis = tname.getSelectionEnd(); tname.select( 0, 10 ); // Markiert die ersten 10 Zeichen tname.selectAll(); // Markiert alles Cursorposition abfragen und setzen int pos = tname.getCaretPosition(); // Cursor hinter den letzten Buchstaben setzen: tname.setCaretPosition( tname.getText().length() ); Textfeld aktivieren und deaktivieren tname.setEditable( false ); // Keine Eingabe möglich, grau if ( tname.isEditable() ) doSometing();



1.5.2 Die Klasse TextArea

Während ein TextField für eine einzeilige Information gedacht ist, stellt eine TextArea einen größeren, rechteckigen Bereich für Textein-/ausgabe zur Verfügung, der auch mit endsprechenden Scrollbalken ausgestattet ist.

♦

♦

♦

♦

TextArea anlegen TextArea guestbook = new TextArea(); TextArea guestbook = new TextArea( "Mit Vorgabe" ); TextArea guestbook = new TextArea( 5, 50 ); // Zeilen, Sp. TextArea guestbook = new TextArea( "Mit Vorgabe", 5, 50 ); TextArea guestbook = new TextArea( "Mit Vorgabe", 5, 50, SCROLLBARS_HORIZONTAL_ONLY ); // etc., siehe API-Doku... Textinhalt verändern guestbook.append( "Killroy was here" ); guestbook.insert( "me too!", 30 ); // Text an Position 30 einfügen guestbook.replaceRange( "Test", 18, 24 ); // Zeichen 18 bis 23 durch "Test" ersetzen Weitere Methoden

TextArea und TextField sind Subklassen von TextComponent. Aus diesem Grunde stehen die bereits zuvor bei TextField erklärten Methoden bis auf die Methoden zur Behandlung von Echo-Zeichen auch für eine TextArea zur Verfügung, denn sie werden aus TextComponent vererbt.

Ereignisse bei Textkomponenten

Wenn innerhalb einer TextComponent die Enter-Taste gedrückt wird, wird ein ActionEvent erzeugt. In diesem Fall liefert die Methode getActionCommand() der ActionEvent den eingegebenen Text, getSource() liefert die auslösende TextComponent (vgl. Button-Beispiel). Wenn sich der Text in einer TextComponent verändert, erzeugt dies jedesmal einen TextEvent. Als TextListener implementiert man die entsprechende Methode textValueChanged( TextEvent e);



2. Arbeiten mit Layout-Managern 2.1 Allgemeines zu Layout-Managern

Jeder Container besitzt einen ihm zugeordneten Layout-Manager. Dieser hat die Aufgabe, die Komponenten in dem Container nach bestimmten Regeln anzuordnen und dabei auch ihre Größe festzulegen.

♦

♦

♦

♦

Um eine plattformunabhängige Lösung zu ermöglichen, sind im Paket java.awt nur Layout-Manager zur Verfügung gestellt, die relative Positionierungsangaben erlauben. Es ist jedoch möglich, eigene Layout-Manager zu schreiben, die auch direkte Positionierungen an bestimmten Koordinaten erlauben. Borland JBuilder besitzt z. B. einen derartigen LayoutManager XYLayout. Java bietet die fünf Layout-Manager FlowLayout, BorderLayout, GridLayout, GridBagLayout und CardLayout. Durch Aufruf der Methode Container.setLayout() wird ein LayoutManager für einen Container festgelegt. Dazu wird eine Instanz des LayoutManagers erzeugt und als Parameter übergeben. Der LayoutManager interagiert selbständig mit dem Container, um das Layout durchzuführen.

Beispiel: import java.awt.*; import java.applet.*; public class GUIApplet extends Applet { protected Button b; public void init() { setLayout( new BorderLayout() ); // Layout festlegen b = new Button( "Hit Me!" ); // Komponente erzeugen add( BorderLayout.CENTER, b ); // Komponente hinzufügen } } 2.2 FlowLayout

FlowLayout ist das Standard-Layout der Container. ♦ ♦ In diesem sehr einfachen Layout werden die Komponenten bei jedem add() einfach der

Reihe nach in einer Zeile hintereinander angeordnet, bis der rechte Rand erreicht ist. Dann erfolgt quasi ein Zeilenumbruch. Die Anordnung innerhalb der Zeilen kann wie folgt beeinflußt werden:

setLayout( new FlowLayout() ); // Default: Zeilen zentrieren setLayout( new FlowLayout( Ausrichtung ) ); // FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT setLayout( new FlowLayout( Ausrichtung, h, v ); // Zwischen den Komponenten h Pixel horizontal, v Pixel // vertikaler Abstand (Ohne Angabe jeweils 5 Pixel)



2.3 BorderLayout

Dieses Layout ist gut geeignet, um bis zu fünf Komponenten in einem Container am linken, rechten, oberen und unteren Rand und im Zentrum anzuordnen.

♦

♦

♦

♦

♦

♦

Der Platz für leere Teile des BorderLayouts darf beliebig schrumpfen, um für die anderen Komponenten Platz zu schaffen.

setLayout( new BorderLayout() ); setLayout( new BorderLayout( 10, 10 ) ); // 10 * 10 Pixel Abstand zwischen den Bereichen

Bei Aufruf von add() wird mit einer Richtungsangabe angezeigt, wo die Komponente platziert werden soll:

add( BorderLayout.NORTH, new Label( "Hier ist oben" ) ); add( BorderLayout.CENTER, new Label( "Hier die Mitte" ) );

2.4 GridLayout

Bei einem GridLayout wird der Container-Bereich tabellenartig in ein Gitter unterteilt. Jede Zelle des Gitters ist gleich groß.

setLayout( new GridLayout( 3, 2 ) ); // Gitter mit drei Zeilen und zwei Spalten setLayout( new GridLayout( 3, 2, 10, 10 ) ); // 10 * 10 Punkte Abstand zwischen den Zellen

Beim Füllen des Containers wird oben links begonnen und bei jedem add() die jeweils nächste Zelle benutzt. Zellen lassen sich "überspringen", indem man in ihnen z. B. ein leeres Label einfügt.



2.5 GridBagLayout

GridBagLayout ist der flexibelste Layout-Manager. Auch hier wird der Containerbereich in ein Gitter unterteilt, jedoch kann man einzelne Komponenten direkt in eine bestimmte Zelle positionieren und hat wesentlich mehr Steuerungsmöglichkeiten.

♦

♦ Die Größe der einzelnen Zellen hängt von den verwendeten Komponenten und Parametern ab. Am ehesten ist das Verhalten eines GridBagLayouts mit dem einer HTML-Tabelle vergleichbar, was die Ausrichtungsmöglichkeiten und Reaktion auf nicht benutzte Zellen, Zeilen und Spalten und die Berechnung der Zellengrößen betrifft.

Anordnung der Komponenten

Die Anordnung der Komponenten erfolgt nicht direkt, sondern mit Hilfe eines zusätzlichen Objektes vom Typ GridBagConstraints.

♦

♦

♦

Zunächst muß eine Instanz von GridBagConstraints erzeugt werden. Anschließend werden die Instanzvariablen dieses Objektes angepaßt und es wird beim Aufruf von add() mit übergeben:

public void init() { ... // Erzeuge und setze GridBagLayout GridBagLayout gbl = new GridBagLayout(); setLayout( gbl ); ... GridBagConstraints gbc = new GridBagConstraints(); ... // Setze Parameter für die Komponente gbc.fill = GridBagConstraints.BOTH; gbc.weightx = 1.0; gbc.gridx = 2; gbc.gridy = 1; // usw., siehe API-Dokumentation ... // Füge die Komponente mit diesen Parametern hinzu Button bOk = new Button( "Ok" ); gbl.setConstraints( bOk, gbc ); add( bOk ); ... }

Die GridBagConstraints-Instanz muß nicht für jede hinzuzufügende Komponente neu erzeugt werden, sondern kann für alle Komponenten wiederverwendet werden, da der Layout-Manager sich beim Aufruf von setConstraints() 'Kopien' der gesetzten Werte macht:

... // Nach Einfügen des Buttons bOk geht es weiter:

gbc.gridx = 3; Button bAbbr = new Button( "Abbrechen" ); gbl.setConstraints( bAbbr, gbc ); add( bAbbr );



Es lassen sich die folgenden Instanzvariablen eines GridBagConstraints setzen: ♦ public int gridx; X-Koordinate der Zielzelle, die erste Zelle hat den Index 0, int-Wert oder GridBagConstraints.RELATIVE = hinter der zuvor hinzugefügten Komponente plazieren public int gridy; Entsprechend für die Y-Koordinate... public int gridwidth; Breite des Darstellungsbereiches, als Anzahl der überspannenden Zellen, int-Wert oder GridBagConstraints.REMAINDER = Komponente als letzte ihrer Zeile plazieren GridBagConstraints.RELATIVE = Komponente als vorletzte ihrer Zeile plazieren public int gridheight; Entsprechend für die Höhe des Darstellungsbereiches... public int fill; Anpassung der Komponentengröße an die ihres Darstellungsbereiches, falls dieser mehr Platz bietet, als eigentlich nötig ist: GridBagConstraints.NONE, HORIZONTAL, VERTICAL, BOTH public int anchor; Verankerung der Komponente in ihrem Darstellungsbereich, falls dieser mehr Platz bietet, als eigentlich nötig ist: GridBagConstraints.CENTER, NORTH, NORTHEAST, EAST, usw. public double weightx; public double weighty; Gewichtung dieser Komponente bei der Vergabe von zusätzlich verfügbarem Platz, relativ für die horizontale und vertikale Anpassung public int ipadx; public int ipady; Innerer leerer Rand um die Komponente in Pixeln, vergrößert ihre minimale Größe public Insets insets; Äußerer Mindestabstand zwischen Komponente u. dem Rand ihres Darstellungsbereiches Beispiel:



2.6 CardLayout

CardLayout ist in gewisser Weise ein Sonderfall. Er teilt den Container in einer zusätzlichen Dimension auf und ermöglicht es, ähnlich wie unter einer Karteikarte die Komponenten abzulegen. Dies sind in der Regel Panels oder Canvas-Instanzen (mehr zu diesen Klassen später).

♦

♦

♦

Beim Aufruf der add-Methode wird der Name der Karteikarte mit übergeben. setLayout( new CardLayout() ); Panel one = new Panel(); // hier würde man noch Komponenten dem Panel one hinzufügen... // ... // Karte unter dem Namen "eins" hinzufügen: add( "eins", one ); Panel two = new Panel(); //... add( "zwei", two ); Panel three = new Panel(); //... add( "drei", three );

Es sind nicht alle Karten zeitgleich zu sehen, sondern es ist immer nur eine im Vordergrund. Die anderen Karten lassen sich dann vergleichbar mit einer Diaschau bei Bedarf in den Vordergrund bringen, es kann auch 'geblättert' werden:

show( this, "zwei" ); // Karte "zwei" anzeigen show( this, "drei" ); // Karte "drei" anzeigen next( this ); // Nächste Karte anzeigen previous( this ); // Zurück zur vorhergehenden Karte first( this ); // Sprung zur ersten Karte last( this ); // Sprung zur letzten Karte Beachte:

Auf der Oberfläche selbst sind keine Karteikartenreiter mit den entsprechenden Labels zu sehen! Die Labels dienen nur anwendungsintern der Unterteilung in verschiedene Bereiche.

♦

♦

2.7 Arbeiten ohne LayoutManager

Mit setLayout( null ) kann man erreichen, daß für diesen Container kein LayoutManager verwendet wird. Man muß dann selbst die Größe und Position aller Komponenten im Container festlegen. Dies geschieht durch Aufruf der Methode setBounds( int x, int y, int width, int height) der Komponente:

setLayout( null ); Button b = new Button( "Klick mich" ); b.setBounds( 20, 20, 100, 100 ); // Geerbt von Component add( b );



3. Mehr über Komponenten 3.1 Allgemeine Eigenschaften von Komponenten

Nahezu alle AWT-Klassen sind Subklassen der Klasse Component und erben damit deren Eigenschaften. Dazu gehört z. B. die Möglichkeit, Mauscursor, Standard-Font und Farben zu setzen etc.

♦

♦

♦

♦

♦

♦

Auch die im Applet verwendeten Methoden paint(), repaint(), update() etc. sind von Component geerbt. Klassen können die Methode paint() überschreiben, um ihre Darstellung auf der Oberfläche zu zeichnen. Im Fall eines Containers wird zunächst dessen (standardmäßig leeres) paint() aufgerufen und danach erst die enthaltenen Komponenten gezeichnet. Überschreibt man paint() für einen Container (Applet-Beispiele!) und fügt dann Komponenten hinzu, überlagern diese also den durch paint() gezeichneten Hintergrund. Nützliche Methoden der Klasse Component:

// c sei eine Komponente, z. B. ein Button c.setCursor( new Cursor( Cursor.WAIT_CURSOR ) ); // Eieruhr-Cursor als aktuellen Cursor setzen // DEFAULT, CROSSHAIR, MOVE, TEXT, WAIT sind möglich c.setBackground( Farbe ); c.setForeground( Farbe ); // Vorder- und Hintergrundfarbe c.setFont( Font ); // Standardfont setzen c.setVisible( boolean ); // Ein- und Ausblenden der Komponente c.setEnabled( boolean ); // Eingabemöglichkeit einstellen, z. B. bei einem Button // Setzen auf false verhindert die Auslösung eines Events 3.2 Ereignisverarbeitung von Komponenten

Die bereits behandelten Key- und Mouse-Events stehen in gleicher Weise auch für jede andere Component zur Verfügung, so daß man sich dafür dort registrieren kann. Beim Verschieben, Ändern der Größe, Ein- und Ausblenden einer Komponente entsteht ein ComponentEvent, für den man sich bei der Komponente als ComponentListener registrieren lassen kann. ComponentListener implementieren die entsprechenden Methoden componentShown(), componentHidden(), componentMoved() und componentResized(). Durch Aufruf der Methode getComponent() des ComponentEvents kann man die auslösende Komponente ermitteln. Beim Wechsel des Eingabefocus entsteht in den betroffenen Komponenten ein FocusEvent, für den man sich als FocusListener registrieren kann. Die entsprechenden Methoden lauten focusGained() und focusLost(). Den übergebenen FocusEvent kann man mit getSource() nach der auslösenden Komponente fragen.



4. Mehr über Container 4.1 Container-Events

Wird eine Komponente einem Container hinzugefügt oder weggenommen, wird ein ContainerEvent durch den Container erzeugt. Ein ContainerListener implementiert entsprechende Methoden componentAdded() und componentRemoved(), der ContainerEvent bietet die Methode getContainer() und die Methode getChild(), die die Komponente zurückliefert.

♦

♦

4.2 Verschachtelte Layouts mit Panels

Mit Hilfe der Klasse Panel, die einen leeren, unbeweglichen Container darstellt, kann man besonders gut verschiedene Layouts miteinander kombinieren, indem man Panels innerhalb von anderen Panels erzeugt.

Beispiel: import java.applet.*; import java.awt.*; public class PanelTest extends Applet { public void init() { setLayout( new GridLayout( 1, 2 ) ); Panel p1 = new Panel(); p1.setLayout( new BorderLayout() ); p1.add( "North", new Button( "p1-North" ) ); p1.add( "South", new Button( "p1-South" ) ); Panel p2 = new Panel(); p2.setLayout( new FlowLayout() ); p2.add( new Button( "p2-1" ) ); p2.add( new Button( "p2-2" ) ); p2.add( new Button( "p2-3" ) ); p1.add( "Center", p2 ); add( p1 ); add( new Button( "Test" ) ); } }



4.3 Die Klasse ScrollPane

Ein ScrollPane ist ein spezieller Container, der genau eine Komponente aufnimmt und diese automatisch horizontal und vertikal scrollt. Die Komponente kann also größer sein als das ScrollPane, das sie aufnimmt.

♦

ScrollPane erzeugen ScrollPane sp = new ScrollPane(); ScrollPane sp = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS); // ALWAYS, NEVER oder AS_NEEDED angeben Panel content = new Panel(); ... // Panel content mit Komponenten füllen sp.add( content ); sp.setSize( 200, 100 ); // Breite und Höhe festlegen add( sp ); Programmgesteuert scrollen Dimension d = sp.getViewportSize(); // Dimensionen Ausschnitt sp.setScrollPosition( 50, 200 ); // Scrolle nach x, y Point p = sp.getScrollPosition(); // Aktuelle Position Schieberegler beeinflussen sp.getVAdjustable().setUnitIncrement( 1 ); // vertikal sp.getHAdjustable().setUnitIncrement( 2 ); // horizontal ... vergleiche Möglichkeiten im Interface Adjustable



5. Weitere einfache Komponenten 5.1 CheckboxGroup

Checkbox-Objekte können zu einer CheckboxGroup zusammengefaßt werden. Im Unterschied zu einzeln verwendeten Checkboxen kann in einer CheckboxGroup immer nur eine der Checkboxen ausgewählt sein. Damit lassen sich also "RadioButtons" realisieren.

♦

♦

CheckboxGroup anlegen

Der CheckboxGroup-Instanz werden nacheinander die einzelnen Checkboxen zugeordnet, indem man für diese Checkboxen einen anderen Konstruktor wie folgt benutzt:

Checkbox cbJa, cbNein, cbVielleicht, cbKeineAhnung; CheckboxGroup wahl = new CheckboxGroup(); ... cbJa = new Checkbox( "Ja", wahl, false ); cbNein = new Checkbox( "Nein", wahl, false ); cbVielleicht = new Checkbox( "Vielleicht", wahl, true ); cbKeineAhnung = new Checkbox( "Keine Ahnung", wahl, false ); add( cbJa ); add( cbNein ); add( cbVielleicht ); add( cbKeineAhnung ); Beachte:

Eine der Checkboxen muß als Vorgabe aktiviert sein (vgl. cbVielleicht). ♦ ♦

♦

♦

Die CheckboxGroup selbst muß nicht dem Container hinzugefügt werden, somit lassen sich die Teile der Checkboxgroup frei und nicht zwingend beieinander positionieren. Die Klasse Checkbox besitzt Methoden getCheckboxGroup() und setCheckboxGroup(), mit denen man zusätzlich die Zugehörigkeit beeinflussen kann. Wird eine Auswahl gemacht, erzeugt die betroffene Checkbox einen ItemEvent, auf den man entsprechend reagieren kann (siehe vorne).

Bestimmen und Setzen der ausgewählten Checkbox Checkbox gew = wahl.getSelectedCheckbox(); if ( gew == cbJa ) { ... } wahl.setSelectedCheckbox( cbNein );



5.2 Choice

Instanzen der Klasse Choice repräsentieren Auswahlfelder und werden je nach System als Popup- oder Dropdown-Liste dargestellt und dienen dazu, aus einer Liste einen Wert auszuwählen

♦

♦

♦

Choice anlegen

Nach dem Erzeugen einer Choice-Instanz werden ihr mit addItem einzelne Listenwerte hinzugefügt, dann wird das Auswahlfeld dem Darstellungsbereich hinzugefügt:

Choice cPizza = new Choice(); cPizza.addItem( "Pizza Salami" ); cPizza.addItem( "Pizza Tonno" ); cPizza.addItem( "Pizza Hawaii" ); cPizza.addItem( "Pizza Calzone" ); add( cPizza ); Werte hinzufügen und entfernen cPizza.insert( "Pizza Mista", 2 ); cPizza.remove( 1 ); cPizza.remove( "Pizza Salami" ); cPizza.removeAll(); Anzahl und Inhalte abfragen int anzahl = cPizza.getItemCount(); String p = cPizza.getItem( 2 ); Auswahl abfragen String pizzaName = cPizza.getSelectedItem(); int pizzaNr = cPizza.getSelectedIndex(); Auswahl setzen cPizza.select( "Pizza Hawaii" ); cPizza.select( 3 ); Auf Ereignisse reagieren

Ebenso wie eine Checkbox sendet auch eine Choice bei einer Auswahl einen ItemEvent. Mit Hilfe der Methode getItemSelectable() des ItemEvents kann man in der entsprechenden Methode itemStateChanged() des ItemListeners die auslösende Choice ermitteln.



5.3 List

List-Instanzen sind rechteckige Bereiche, in denen eine Liste dargestellt wird. Aus dieser können auch mehrere Werte ausgewählt werden.

♦

♦

♦

♦

♦

Ist die Liste länger als der Darstellungsbereich, werden automatisch Bildlaufleisten hinzugefügt.

Liste anlegen

Die Anzahl der am Bildschirm sichtbaren Zeilen kann im Konstruktor vorgegeben werden. Außerdem muß angegeben werden, ob jeweils nur ein Element (false) oder mehrere (true) ausgewählt werden dürfen:

List plan = new List(); // Keine Mehrfachauswahl List plan = new List( 3, true ); // Mehrfachauswahl plan.addItem( "Merkur" ); plan.addItem( "Venus" ); plan.addItem( "Erde" ); plan.addItem( "Mars" ); plan.addItem( "Jupiter" ); add( plan ); Mit der Liste arbeiten

List bietet sehr viele Methoden, die z. B. wie folgt eingesetzt werden können: plan.setMultipleMode( false ); if ( plan.isMultipleMode() ) ... plan.addItem( "Saturn" ); plan.addItem( "Pluto", 0 ); // Vorne einfügen plan.replaceItem( "Uranus", 2 ); // Nr. 2 ersetzen plan.delItem( 3 ); String s = plan.getItem( 1 ); String sel = plan.getSelectedItem(); String[] sels = plan.getSelectedItems(); int isel = plan.getSelectedIndex(); int[] isels = plan.getSelectedIndexes(); int num = plan.getItemCount(); ... und einige mehr, siehe API-Dokumentation! Auf Ereignisse reagieren

Wie die Choice erzeugt auch die List entsprechende ItemEvents, wenn Items selektiert oder deselektiert werden. Ein Doppelklick auf einen Eintrag löst einen ActionEvent aus...



6. Frames und Dialoge 6.1 Die Klasse Frame

Eigenständige Fenster sind im AWT Instanzen der Klasse Frame. Diese können dann aus einem Applet oder einer Application heraus erzeugt und angezeigt werden.

♦

Beispiel: import java.awt.*; public class FrameTester { public static void main( String[] args ) { Frame f = new Frame( "Fenstertitel" ); // Erzeugen // f.setTitle( String s ); // (Titel setzen) // String t = f.getTitle(); // (Titel holen) f.setSize( 300, 200 ); // Fenstergröße f.setLocation( 0, 0 ); // Fensterposition //f.setIconImage( Image i ); // (Icon des Fensters) f.setLayout( new FlowLayout() ); // Layout-Manager Button b = new Button( "Ok" ); // Button erzeugen //... // Listener erzeugen... f.add( b ); // Komponenten hinzuf. f.setVisible( true ); // Fenster anzeigen f.requestFocus(); // Focus erbitten try{ Thread.sleep( 10000 ); } // 10 Sek. warten catch( InterruptedException ex ){} f.setVisible( false ); // Fenster ausblenden f.dispose(); // Ressourcen freigeben System.exit( 0 ); // Exit-Code aus Anwendung zurückgeben } } Hinweis:

Die Auflösung des Bildschirms läßt sich über die Klasse Toolkit ermitteln, so daß man z. B. den Frame als Vollbild oder zentriert anzeigen kann:

♦

Dimension d = Toolkit.getDefaultToolkit().getScreenSize(); int w = d.width; int h = d.height; // Breite und Höhe in Pixeln



6.2 Auf Fensterereignisse reagieren ♦

♦

♦

Bei Auftreten entsprechender Ereignisse in Frame oder Dialog wird ein WindowEvent ausgelöst, den beim Fenster registrierte WindowListener bearbeiten. Es existieren folgende Methoden

public void windowActivated( WindowEvent e ) // Fenster gerade neu erzeugt oder wieder im Vordergrund public void windowDeactivated( WindowEvent e ) // Fenster geht in den Hintergrund public void windowIconified( WindowEvent e ) // Fenster auf Icongröße verkleinert public void windowDeiconified( WindowEvent e ) // Fenster aus Icon wieder vergrößert public void windowOpened( WindowEvent e ) // Fenster wurde geöffnet public void windowClosing( WindowEvent e ) // Fenster soll geschlossen werden, z. B. mit ALT+F4 public void windowClosed( WindowEvent e ) // Fenster wurde geschlossen

Java-Fenster lassen sich nicht automatisch schließen. Die Applikation muß das Ereignis windowClosing abfangen und das Fenster dann kontrolliert schließen, z. B. wie folgt:

import java.awt.*; public class FrameTester { protected static Frame f; public static void main( String[] args ) { f = new Frame( "Fenstertitel" ); f.addWindowListener( new WindowAdapter() { public void windowClosing( WindowEvent e ) { f.setVisible( false ); f.dispose(); System.exit( 0 ); } } ); f.setSize( 300, 200 ); f.setLocation( 0, 0 ); f.setVisible( true ); f.requestFocus(); } }

Die Vorgehensweise ist für die Klassen Frame und Dialog identisch.



6.3 Die Klasse Dialog

Neben Frames existiert noch eine weitere Fensterklasse, die Klasse Dialog. Sie realisiert ein Dialogfenster, z. B. einen Suchen-Dialog. Dialogfenster sind an einen Frame gebunden, der sie "besitzt", daher wird eine Referenz auf diesen Frame im Konstruktor mit übergeben.

♦

♦ Dialogfenster können modal sein, d. h. sie blockieren den Eingabefocus, so daß solange der Dialog angezeigt wird, kein anderes Fenster aktiv sein kann.

Beispiel: Dialog erzeugen Frame frame; // ... frame erzeugen usw. Dialog d1 = new Dialog( frame, false ); // nicht modal Dialog d2 = new Dialog( frame, "Suchen", true );// modal Modal-Modus setzen / ermitteln boolean modal = d1.isModal(); //Ist der Dialog modal? d2.setModal( false ); Größenänderung unterbinden / ermöglichen boolean res = d1.isResizable(); //Ist das Fenster veränderbar? d1.setResizable( false ); 6.4 Die Klasse FileDialog

Java bietet einen plattformunabhängigen Zugriff auf den (plattformabhängigen) Datei-Dialog über die Klasse FileDialog.

♦

Beispiele: FileDialog dLoad = new FileDialog( frame, "Datei öffnen" ); dLoad.show(); // blockiert bis Auswahl erfolgt ist String datei = dLoad.getFile(); String verz = dLoad.getDirectory(); if( datei != null ) ... FileDialog dSave = new FileDialog( frame, "Datei speichern", FileDialog.SAVE ); // Man kann Vorgaben für Datei und Verzeichnis machen: // dSave.setFile( "img0000.gif" ); // dSave.setDirectory( "c:\\windows\\temp" ); dSave.show(); String datei = dSave.getFile(); String verz = dSave.getDirectory(); if( datei != null ) ...



7. Menüs und Menüleisten

Die Klassen MenuBar, Menu, MenuItem und CheckboxMenuItem ermöglichen den Aufbau von Menüs in graphischen Oberflächen.

♦

♦ Nur ein Frame darf eine MenuBar besitzen, kein Dialog, kein Applet usw.! 7.1 Menüs definieren MenuBar mb = new MenuBar(); Menu mDatei = new Menu( "Datei" ); mDatei.add( new MenuItem( "Neu" ) ); ... Menu mBearb = new Menu( "Bearbeiten" ); mBearb.add( new MenuItem( "Ausschneiden" ) ); mBearb.add( new MenuItem( "Kopieren" ) ); mBearb.add( new MenuItem( "Einfügen" ) ); mBearb.addSeparator(); mBearb.add( new CheckboxMenuItem( "AutoDelete an" ) ); mBearb.disable(); Menu mHilfe = new Menu( "?" ); mHilfe.add( new MenuItem( "Info" ) ); mb.add( mDatei ); mb.add( mBearb ); mb.setHelpMenu( mHilfe ); Frame f; ... // ... von irgedwo her f.setMenuBar( mb ); // Das geht nur in einem Frame... Hinweis:

Da Menu eine Subklasse von MenuItem ist, ist jedes Menu also auch ein MenuItem, d. h. man kann also Untermenüs erzeugen...

♦

♦

♦

7.2 Auf Menüereignisse reagieren

Wenn der Benutzer einen Menüpunkt anklickt, wird ein ActionEvent durch das entsprechende MenuItem erzeugt und an die beim MenuItem registrierten ActionListener weitergeleitet. Für jedes relevante MenuItem muß man bei diesem einen Listener registrieren, d. h. innerhalb des gleichen Menüs können auch verschiedene Listener auf verschiedene MenuItems reagieren. In der Methode actionPerformed des Listeners kann der ActionEvent e untersucht werden:

String menuItemLabel = e.getActionCommand(); MenuItem menuItem = (MenuItem)( e.getSource() );


VII. Ein- und Ausgabe, Netze, Dateien und Fortgeschrittenes 127

VII. Ein- und Ausgabe, Netze, Dateien und Fortgeschrittenes



1. Ein- und Ausgabeströme in Java

Klassen für Ein-/Ausgabeoperationen sind im Paket java.io untergebracht. Ein- und Ausgabe in Java ist stromorientiert: Man liest aus einem Strom von Eingabedaten, der z. B. aus dem Netz oder aus einer Datei kommt und schreibt Daten in einen Ausgabe-strom, der als Senke z. B. ebenfalls eine Netzverbindung, eine Datei o. ä. haben kann.

♦

♦

♦

Als Basis aller Ein- und Ausgabeströme existieren die Klassen InputStream und OutputStream für elementare, Byte-orientierte Ein- und Ausgabe. Der Standard-Eingabestrom System.in ist z. B. eine Instanz von InputStream. Auf diesen Basisströmen bauen spezialisiertere Stream-Klassen auf, z. B. PrintStream zur Ausgabe (System.out und System.err sind PrintStreams).

Byteorientierte Ein- und Ausgabe mit InputStream und OutputStream

Alle Basis-Ein- und Ausgabeströme besitzen Methoden read() und write() zum Lesen und Schreiben von Bytes. Mit den Unterklassen FileInputStream und FileOutputStream kann man z. B. Dateien byteweise lesen und schreiben:

Beispiel: Kopieren einer Datei import java.io.*; public class CopyFile { public static void main( String[] args ) throws Exception { InputStream is = new FileInputStream ( args[ 0 ] ); OutputStream os = new FileOutputStream( args[ 1 ] ); byte[] buffer = new byte[4096]; // Puffer für 4 KByte int n; // Anzahl Bytes die gelesen wurden while( ( n = is.read( buffer, 0, buffer.length ) ) != -1 ) // Gelesene Bytes werden in das Array buffer geschrieben // Das Array wird ab Index 0 gefüllt // Es werden maximal buffer.length Bytes gelesen // Wenn der Eingabestrom beendet ist, gibt read –1 zurück os.write( buffer, 0, n ); // Schreibe n Bytes beginnend ab Index 0 aus dem Array // in den Ausgabestrom is.close(); os.close(); } } Aufruf:

java CopyFile c:\x\y\quelle.dat d:\a\b\ziel.dat



Weitere interessante Klassen zur Ein- und Ausgabe auf Byte-Ebene ♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

♦

Im Paket java.util.zip existieren Ein- und Ausgabeströme zum Lesen und Schreiben von ZIP- und GZIP-Strömen und -Dateien. Die Klassen DataInputStream und DataOutputStream ermöglichen es, einfache Java-Datentypen in einen Ausgabestrom zu schreiben bzw. wieder daraus zu lesen. Die Klasse RandomAccessFile ermöglicht statt einer sequentiellen Verarbeitung den wahlfreien Zugriff auf bestimmte Positionen einer Datei.

Reader- und Writer-Klassen

Da die Stream-Klassen auf der Basis von einzelnen Bytes arbeiten, sind sie nicht überall direkt dazu verwendbar, Zeichen und Strings zu lesen bzw. zu schreiben, da Zeichen ja Java-intern als UniCode-Zeichen in 16 Bit abgelegt sind, in einer Datei in der Regel aber als 8-Bit-Zeichen stehen. Daher hat man ab JDK 1.1 die Klassen für Byteströme um sogenannte Reader- und Writer-Klassen ergänzt, die aus einem Bytestrom einen Strom von UniCode-Zeichen machen und umgekehrt. Beim Lesen einer Datei wandelt ein Reader z. B. die 8-Bit-Darstellung der jeweiligen Codepage in die entsprechende 16-Bit-Darstellung des UniCode um. Dabei kann optional auch angegeben werden, in welcher Codepage die Daten codiert sind.

OuputStreamWriter: Wandelt Character-Streams in Byte-Streams um FileWriter: Schreibt zeichenweise in eine Datei, Codepage kann z. B. auch angegeben werden. PrintWriter: Gibt alle Basis-Datentypen als Zeichenkette aus, z. B. System.out BufferedWriter: Puffert Ausgabeströme StringWriter: Schreibt Daten in einen StringBuffer InputStreamReader: Wandelt einen Byte-Stream in einen Character-Stream um FileReader: Liest aus einer Datei PushbackReader: Erlaubt es, gelesene Zeichen wieder in den Strom zurückzuschieben BufferedReader: Puffert Leseoperationen und liest komplette Zeilen LineNumberReader: BufferedReader, der zusätzlich Zeilen mitzählt StringReader: liest aus einem String

Datenströme und Reader / Writer werden bei der Erzeugung mit new() oft ineinander verschachtelt (siehe unten) so daß der eine Strom jeweils auf den Funktionen eines darunterliegenden Stromes aufbaut.



Beispiel 1:

Zeilenweises Ausgeben einer reinen Textdatei: ♦ import java.io.*; public class ReaderTest { public static void main( String[] args ) { try { BufferedReader br = new BufferedReader( new FileReader( "c:\\autoexec.bat" ) ); String line; while( ( line = br.readLine() ) != null ) System.out.println( line ); } catch( Exception ex ){ System.out.println( "Fehler!" ); } } } Beispiel 2:

Ein paar Textzeilen in eine Datei schreiben: ♦ PrintWriter datei = new PrintWriter( new FileWriter( "index.html" ) ); datei.println( "<HTML><HEAD><TITLE>Ein Test</TITLE></HEAD>" ); datei.println( "<BODY> Hallo Welt! </BODY></HTML>" ); datei.close(); Beispiel 3:

Lesen von der Standard-Eingabe: ♦ BufferedReader konsole = new BufferedReader( new InputStreamReader( System.in ) ); System.out.print( "Wie viele Waschmaschinen wollen Sie?" ); int anzahl = Integer.parseInt( konsole.readLine() ); System.out.println( "Menge: " + anzahl + " Stück" ); System.out.print( "Und wohin soll ich liefern?" ); String anschrift = konsole.readLine();

...



2. Datei- und Verzeichnisinformationen

Die Klasse File repräsentiert Informationen über eine Datei (nicht die Datei selbst). ♦ Klassenvariablen String vTrenner = File.separator; // Verzeichnistrenner ( Unix: "/", Windows: "\" ) hier String pTrenner = File.pathSeparator; // Pfadtrenner für Pfadlisten ( ":" bzw. ";" ) hier File-Instanz erzeugen File f = new File( dir, dateiname ); File f = new File( pfadname ); // "c:\temp\test.java" Informationen abfragen boolean b; b = f.canRead(); // Lesender Zugriff möglich? b = f.canWrite(); // Schreibender Zugriff möglich? b = f.exists(); // Gibt es diese Datei / Verzeichnis? b = f.isAbsolute(); // Ist die Pfadangabe absolut? b = f.isDirectory(); // Handelt es sich um ein Verzeichnis? b = f.isFile(); // oder um eine Datei? String s; s = f.getAbsolutePath(); // Absoluter Pfad der Datei s = f.getName(); // Datei- bzw. Verzeichnisname s = f.getParent(); // Pfad des Elternverzeichnisses s = f.getPath(); // Pfad der Datei long l; l = f.lastModified(); // Letzte Änderung in ms seit 1.1.70 l = f.length(); // Länge in Bytes Löschen und umbenennen boolean ok = f.delete(); boolean ok = f.renameTo( new File( "Neu.txt" ) ); Arbeiten mit Verzeichnissen String aktuelles = System.getProperty( "user.dir" ); // Aktuelles Arbeitsverzeichnis dieser Java Application String[] list = f.list(); // Verzeichnisinhalt String[] list = f.list( FilenameFilter ); // siehe Schnittstelle FilenameFilter in API-Docs!! boolean ok = f.mkdir(); // Erzeugt dieses Verzeichnis boolean ok = f.mkdirs(); // Erzeugt rekursiv Verzeichnis(se)



3. Netzwerkkommunikation mit Java

Java bietet grundlegende Funktionen zur Arbeit in Netzen auf TCP/IP- und UDP-Basis, mit denen jedes darauf basierende höhere Protokoll implementiert werden kann (FTP, TELNET, HTTP, POP3, SMTP, NNTP, SNMP, ...).

♦

♦

♦

♦

♦

♦

♦

♦

Es lassen sich Client- und Serversockets für TCP, Client- und Server-Datagramm-Sockets für UDP einrichten. Eine Klasse URL nimmt in ihren Instanzen URLs auf, die Klasse InetAddress nimmt in ihren Instanzen eine Hostadresse auf. Näheres in spezieller Literatur und in der API-Dokumentation!

3.1 Einfache Netzoperationen aus Applets heraus:

this.getAppletContext().showDocument( eineURLInstanz ); // weist den Browser an, diese URL anzufordern. // Es gibt auch die Möglichkeit, ein target anzugeben...

Instanzen vom Typ URL besitzen eine Methode openStream(). Diese liefert einen InputStream zurück, der dann wie jeder andere weiterverarbeitet werden kann:

try { URL url = new URL("http://www.xy.com/irgendwas.txt" ) ; BufferedReader data = new BufferedReader( new InputStreamReader( url.openStream() ) ); String line; while ( ( line = data.readLine() ) != null ) System.out.println( line ); data.close(); } catch( Exception ex ) { System.out.println( "Ein Fehler ist aufgetreten." ); } 3.2 Kommunikation zwischen Applets:

Applets der gleichen Seite können ihre public-Methoden untereinander aufrufen: Applet uhr = this.getAppletContext().getApplet( "Uhr" ); uhr.stop();

Der Name eines Applets kann im <APPLET>-Tag z. B. mit NAME="Uhr" definiert werden. Die Methode getApplets() liefert alternativ eine komplette Enumeration der Applets der Seite:

Enumeration e = this.getAppletContext().getApplets(); while ( e.hasMoreElements() ) { Applet applet = (Applet)e.nextElement(); applet.doSomething(); }



4. Java Database Connectivity (JDBC)

Verfügbar als Zusatzpaket für JDK 1.0, im Sprachumfang enthalten ab JDK 1.1 ♦ ♦

♦

♦

♦

Java-API, um auf SQL-Ebene von Java aus auf beliebige relationale Datenbanken zuzugreifen. Die Schnittstelle ist dabei unabhängig von der Plattform und der Datenbank, der Java-Code muß bei einem Wechsel also nicht geändert werden. JDBC ist in Anlehnung an die Datenbank-Schnittstelle ODBC entwickelt worden. Eine JDBC-to-ODBC-Bridge-Treiber wird mit den JDBC-Klassen von Sun mitgeliefert. Klassen für Select-Abfragen, Cursors, Connections etc. sind verfügbar, die SQL-Datentypen werden einheitlich auf Java-Datentypen abgebildet. Nahezu alle Datenbanksysteme (Oracle, DB2, Access, ...) bieten inzwischen mächtige JDBC-Treiber. Es existieren verschiedene Treiber-Architekturen, im Idealfall ist der JDBC-Treiber selbst in Java geschrieben, so daß auf dem Client keine Installation von Treibern nötig ist, sondern der Download der Java-Klassen z. B. durch ein Applet ausreicht.

Beispiel: import java.sql.*; public class Test { public static void main( String[] args ) throws Exception { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); // JDBC-Treiber für ODBC-Verbindungen registrieren Connection c = DriverManager.getConnection( "jdbc:odbc:Bank;UID=Meier;PWD=MySecret" ); // Verbindungsaufbau zur ODBC-zugänglichen Datenbank // "Bank", User "Meier" mit Passwort "MySecret" Statement s = c.createStatement(); ResultSet r = s.executeQuery( "SELECT kontoNr, betrag FROM konten" ); // SQL-Select-Abfrage ausführen while ( r.next() ) // Für jeden Datensatz... { int betrag = r.getInt( "betrag" ); // Hole int-Wert über Namen der Spalte int nr = r.getInt( 0 ); // Hole int aus Spalte mit Index 0 (KontoNr) System.out.println( kontoNr + " / " + betrag ); } r.close(); c.close(); } }



5. Swing ♦ ♦ ♦ ♦

♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦ ♦

Verfügbar als Zusatzpaket für JDK 1.1, im Sprachumfang enthalten ab JDK 1.2 Mächtige Klassenbibliothek zur Erstellung graphischer Oberflächen mit Java Realisiert als Aufsatz auf das AWT, Alternative zu den AWT-Komponenten Verwendet keine native peers zur Darstellung, daher ist es einfacher, Oberflächen zu erzeugen, die auf jedem System gleich aussehen. Einige Stichwörter aus dem Leistungsumfang:

Pluggable Look and Feel: Unix, Windows, Java, Mac, zur Laufzeit änderbar Drag and Drop zwischen Java-Elementen Unterstützung der Zwischenablage Grafische, animierte und roll-over-Buttons Tool Tips ('gelbe Kästchen') Fortschrittsbalken Tree Controls, auch mit selbstdefinierten Icons HTML Viewer –Komponente Komponenten für Tabellendarstellungen Toolbars

Beispiele: Table

Listbox

Toolbar

Tree Control



6. Java Servlets

Java Servlets sind Java-Anwendungen, die im Prozess eines Web-Servers laufen, ähnlich wie Applets in einem Browser laufen. Ein Servlet-fähiger Web-Server besitzt dazu eine Java Virtual Machine, um Java Bytecode auszuführen und bietet eine standardisierte Servlet API, gegen die man Servlets programmieren kann.

♦

♦

♦

♦

♦

♦

♦ ♦

♦

Nahezu alle gängigen Web-Server (Apache, Netscape, Domino, Microsoft) unterstützen inzwischen Servlets, oft sind zusätzlich Servlet Plug-Ins von Drittanbietern verfügbar. Vergleichbar mit CGI kann man einen HTTP Request an ein Servlet weiterleiten, das dann z. B. Daten aus einem HTML-Formular entgegennimmt und verarbeitet und dann als Antwort eine HTML-Seite erzeugt. Servlets können, abgesehen davon, daß sie keine graphische Oberfläche besitzen, den vollen Sprachumfang von Java nutzen, z. B. via JDBC eine Datenbank ansprechen. Servlets sind plattformunabhängig, man kann also das Servlet, einmal geschrieben, unverändert in einem anderen Web-Server auf einer anderen Plattform laufen lassen. Servlets sind schneller als CGI. Wenn ein Request bearbeitet werden soll, wird bei CGI ein neuer Prozess gestartet. Dieser Kontextwechsel zwischen den Prozessen kostet Zeit. Servlets laufen und bleiben nach dem Start im Web-Server-Prozess, der Wechsel ist nicht nötig, stattdessen wird für jeden Request einfach ein neuer Thread gestartet, der ihn bearbeitet. Dies geschieht automatisch und muß nicht programmiert werden. Die Java Servlet API bietet volle Unterstützung für das Bearbeiten von Cookies. Servlets besitzen ein integriertes Session Management, um Objekte in einer Session zu speichern. Wenn mehrere Requests vom gleichen Client bearbeitet werden, lassen sich so zwischen den einzelnen Requests Zustände erhalten, z. B. Login-Informationen. Dies wird dynamisch und automatisch entweder über Cookies oder URL Rewriting realisiert. Servlets können über eine URL von Browsern aufgerufen werden, in HTML-Seiten ver-gleichbar mit Server Side Includes eingebunden werden, oder sich gegenseitig aufrufen.

Beispiel: Aufruf über http://www.bank.de/servlet/KontoServlet?kontoNr=12345 import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class KontoServlet extends HttpServlet { public void doGet( HttpServletRequest req, HttpServletResponse res ) throws ServletException, IOException { ServletOutputStream out = res.getOutputStream(); res.setContentType("text/html"); int nr = Integer.parseInt(req.getParameter( "kontoNr" )); out.println( "<HEAD><TITLE>Ihr Konto:</TITLE></HEAD>" ); out.println( "<BODY>" ); out.println( "Ihr Kontostand:" ); out.println( Konto.gibKonto( nr ).gibKontoStand() ); out.println("</BODY>"); out.close(); } }


http://www.irgendwo.com/servlet/HelloWorld?name=Willi

Documents

Einführungspraktikum Java - duepublico.uni-duisburg-essen.de · ♦ Java 1 und JDK 1.0.2: Wird von allen Java-fähigen Web-Browsern und Plattformen unterstützt, aus praktischer