|
Archive-name: de/comp-lang-java/faq
Posting-Frequency: weekly (Friday) Last-modified: 2004-10-02 Version: 1.44 URL: ftp://rtfm.mit.edu/pub/usenet-by-group/de.answers/de/comp-lang-java/faq, http://www.faqs.org/faqs/de/comp-lang-java/faq Expires: 21 Oct 2005 00:00:00 CEST Tab-Width: 4 Page-Width: 74 See reader questions & answers on this topic! - Help others by sharing your knowledge FAQ (Frequently Asked Questions) der Newsgroup de.comp.lang.java v1.44 ========================================================================= Inhalt: ------- 1. Allgemeines 1.1. Allgemeine Hinweise zum Posten 1.2. Worum geht es in dieser Newsgroup? 1.3. Wie kommen häufig gestellte Fragen in diese FAQ? 1.4. Wie kommen die Bugs aus der FAQ? 1.5. TAGS-Konventionen zu einem einheitlichen Aussehen 1.6. Ich bekam als Antwort auf meine Frage eine seltsame Buchstaben- kombination zugeschickt. Was ist das und wie kann ich es lesen? 2. Was man über Java wissen sollte 2.1. Was ist Java? 2.2. Verwandtschaft von Java mit anderen Sprachen? 2.3. WebBrowser und Java 2.4. Erste Schritte in Java 2.5. Ich habe das HelloWorld-Programm aus meinem Java-Buch abgeschrieben, aber es funktioniert nicht. :-( 3. Häufig gepostete Fragen 3.1. [LANG] - Die Sprache Java. 3.1.1. Gibt es in Java keine Zeiger wie in C++? 3.1.2. Warum ist Referenz nicht gleich Referenz? 3.1.3. Wie werden in Java Funktionsparamter übergeben, by value oder by reference? 3.1.4. Warum gibt es in Java keine Destruktoren wie in C++? 3.1.5. Warum funktioniert die equals Methode nicht? 3.1.6. Wenn ich eigene Objekte mit einer Hashtable/HashMap verwalte, kommt es zu sonderbaren Effekten. Wieso? 3.1.7. Was bedeutet das Schlüsselwort final? 3.1.8. Warum wird der dynamische Parametertyp bei überladenen Funktionen nicht beachtet? 3.1.9. Was bedeutet super()? 3.1.10. Was sind anonyme Arrays? 3.1.11. Gibt es in Java einen Prä-Prozessor wie in C++? 3.1.12. Existiert der const Modifizierer von C++ auch in Java? 3.1.13. Wie kann man Referenzen von Übergabeparametern ändern? 3.1.14. Wie erzeuge ich eine tiefe Kopie eines Objektes mit möglichst wenig Aufwand? 3.1.15. Wie kann ich in Java eine dem Programmierer unbekannte Anzahl gleichartiger Objekte erzeugen und ihnen passende Namen zuweisen, also label1, label2 usw.? 3.1.16. Wie kann ich den Typ enum aus C++ in Java umsetzen? 3.1.17. Kann man Mehrfachvererbung mit Java simulieren? 3.1.18. Wie realisiere ich eine variable Parameterliste? 3.1.19. Wie realisiere ich eine Methodenauswahl nach den dynamischen Parametertypen? 3.1.20. Sind Methoden in Java immer virtuell? 3.1.21. Ich stosse ab und zu auf den Begriff "Wrapper-Klassen". Könnte mir jemand erklären was das ist? 3.1.22. Warum ist private nicht privat? 3.2. [STRING] - Strings. 3.2.1. Wie vergleiche ich zwei Strings in Java? 3.2.2. Wie wandle ich einen String in einen Integer? 3.2.3. Wie wandle ich einen Integer in einen String um? 3.2.4. Wie wandle ich einen Integer in einen HexString um? 3.2.5. Wie kann ich eine Zahl formatieren und wie lege ich die Anzahl der Nachkommastellen fest? 3.2.6. Wie kann ich ein Datum formatieren? 3.2.7. Wie kann ich in einem String oder StringBuffer mehrere Zeichen suchen und ersetzen? 3.2.8. Gibt es reguläre Ausdrücke in Java (regular expressions)? 3.3. [IO] - Eingabe/Ausgabe, Streams, etc. 3.3.1. Verlangsamt Serialisierung mein Programm? 3.3.2. Wie kann ich rekursiv einen Verzeichnisbaum abarbeiten? 3.3.3. Wie kann ich aus Dateien zeilenweise lesen? 3.3.4. Wie kann ich Exponentialzahlen (z.B. 1.09E+008) aus einer Datei lesen? 3.3.5. Wie kann ich mit Java Dateien kopieren? 3.3.6. Warum kann ich meine Bilder nicht mehr laden, nachdem ich sie in ein Jar gesteckt habe? 3.4. [NET] - Netzwerk. 3.4.1. Wie kann ich einen Ping in Java realisieren? 3.5. [AWT] - Abstract Window Toolkit. 3.5.1. Wenn ich einen Listener bei mehreren Buttons anmelde, wie kann ich dann unterscheiden, welcher gedrückt wurde? 3.5.2. Kann ich ein Fenster (Frame/JFrame) maximieren? 3.5.3. Wie tausche ich die Kaffeetasse im blauen Balken aus? 3.6. [SWING] - Swing, das bevorzugte GUI. 3.6.1. Wie mache ich globale Font-Änderung für meine Komponenten? 3.6.2. Wie kann ich bei der Eingabe in ein JTextField die Anzahl der eingebbaren Zeichen beschränken? 3.6.3. Wie setze ich den Cursor an den Anfang der JTextArea? 3.6.4. Wie scrolle ich an das Ende der JTextArea? 3.6.5. Wie bekomme ich es hin, das der Benutzer in meiner JTable keine Eingaben tätigen kann? 3.6.6. Wie bekomme ich eine horizontale ScrollBar bei JTable? 3.6.7. Wie scrolle ich ans Ende von JTable? 3.6.8. Wie verhindere ich ein reordering der Spalten bei JTable? 3.6.9. Wie verhindere ich ein Resizen der Spalten bei JTable? 3.6.10. Wie ändere ich die Hintergrundfarbe von JScrollPane? 3.6.11. Wie kann ich ein JLabel dazu bringen, seinen Hintergrund zu füllen? 3.6.12. Warum reagiert meine GUI nicht, während eine längere Berechnung ausgeführt wird? 3.7. [APPLET] - Java-Applets und ihre Zusammenarbeit mit Browsern. 3.7.1. Welche JDK-Version sollte ich für Applets verwenden, die möglichst allgemein lauffähig sein sollen? 3.7.2. Wie bekomme ich den Internet Explorer dazu, das Plugin anstelle der integrierten JVM zu benutzen. 3.7.3. Was dürfen unsignierte Applets nicht aus Sicherheitsgründen? 3.8. [SERVER] - Servlets und andere Server-Implementierungen in Java. 3.9. [NONCORE] - Klassen/Packages, die über den Kern der Sprache hinausgehen, also Java3D etc. 3.10. [OOP] - OOP-Konzepte und Patterns in Java. 3.10.1. Was bedeutet Vererbung im OO-Kontext? 3.10.2. Was bedeutet Aggregation im OO-Kontext? 3.10.3. Was bedeutet Assoziation ist OO-Kontext? 3.10.4. Was bedeutet Benutzung im OO-Kontext? 3.10.5. Worin liegen die Unterschiede zwischen abstrakten Klassen und Interfaces? 3.10.6. Was ist eine anonyme innere Klasse? 3.10.7. Was ist ein immutable Objekt? 3.11. [JDK] - Virtuelle Maschinen, alles über JDKs, deren Installation und Verwendung. 3.11.1. Was ist ein Java Development Kit (JDK) 3.11.2. Was ist ein Java Runtime Environment (JRE) 3.11.3. Was ist eine Java Virtual Machine (JVM) 3.11.4. Wie konfiguriere ich JDK1.3/1.4 unter Linux oder Unix? 3.11.5. Wie installiere und konfiguriere ich das jdk unter Windows 9x/Me/NT/2000 richtig? 3.12. [TOOLS] - Java-Zusatz-Tools, zum Beispiel IDEs, Build-Tools, Profiler, etc. 3.12.1. Welche IDE muss ich verwenden? 3.12.2. Wie kann man eine Java-Anwendung in eine EXE-Datei umwandeln? 3.13. [MATH] - Mathematik, Arithmetik, Gleitpunktzahlen, Funktionen. 3.13.1. Warum rechnet Java falsch? 3.13.2. Wie runde ich eine Gleitkommazahl? Wie formatiere ich eine Gleitkommazahl? 3.13.3. Wie kann ich in Java Zufallszahlen im Bereich 0..n erzeugen? 3.14. [MISC] - Alles, was nicht in eine der anderen Rubriken paßt. 3.14.1. Ich komme mit dem import-Statement nicht klar, was mache ich falsch? 3.14.2. Warum gibt es Probleme bei final Werten in Verbindung mit elementaren Typen? 3.14.3. Was bedeuten "$" im Namen von Class-Files? 3.14.4. Wie lassen sich Bilder im Dateiformat XYZ laden oder speichern? 3.14.5. Was geht nicht mit Java? 3.14.6. Wie kann ich in meinem Java-Programm ein HTML-Dokument anzeigen lassen? 3.14.7. Unter Windows werden in der Konsole (DOS-Eingabe- aufforderung) die Umlaute falsch ausgegeben. Wie kann ich das korrigieren? 3.15. [ERROR] - Fehlermeldungen. 3.15.1. Warum findet Java den Konstruktor nicht? 3.15.2. Warum bekomme ich eine "NoClassDefFoundError" Fehlermeldung beim Starten von java? 3.15.3. Warum bekomme ich eine "Couldn't read <Name>" Fehlermeldung beim Kompilieren mit javac? 3.15.4. Warum bekomme ich eine "class <Name> must be defined in a file called <Name>" Fehlermeldung beim Kompilieren von javac? 3.15.5. Warum wird beim Zugriff auf ein korrekt initialisiertes Objekt-Array eine NullPointerException geworfen? 3.15.6. Warum bekomme ich eine NullPointerException, wenn ich versuche, auf Methoden oder Attribute von in einem Array gespeicherten Objekten zuzugreifen? 3.15.7. Warum meckert der Compiler bei nicht initialisierten final Variablen? 3.15.8. Was hat die Compilerfehlermeldung "... is deprecated" zu bedeuten? 3.16. [ClassLoader] - Alles über Classloader 3.16.1 Wie funktionieren Classloader? 3.16.2 Warum macht der Classloader im Servlet-Container Probleme? Warum funktioniert das Einlesen von Ressourcen ueber den Classloader bei mir nicht? 3.16.3 Wie lade ich eine Klasse neu? 3.16.4 Wie baue ich einen Plugin-Mechanismus? 3.16.5 Gibt's dazu auch Beispielcode? 3.16.6 ClassLoader Ressourcen zu 3.16.1 bis 3.16.5 4. Bücher zum Thema Java 4.1. Kann mir jemand gute Literatur zum Thema Java empfehlen? 5. Themenverwandte Internet Ressourcen 5.1 WWW-Sites 5.2 Newsgroups 5.3 Mailinglisten 6. JavaScript Internet Ressourcen. 6.1 WWW-Sites 6.2 Newsgroups 7. Credits _____________________________________________________________________ 1. Allgemeines ============== 1.1. Allgemeine Hinweise zum Posten ----------------------------------- Wenn du neu im Usenet bist, solltest du auf jeden Fall die Texte in der Newsgroup <news:de.newusers.infos> lesen. Du findest sie auch im WWW auf <URL:http://www.kirchwitz.de/~amk/dni/>. In diesen Texten erhält man einen Überblick über die im Usenet üblichen Regeln ("Netiquette"). Auf diese Weise lassen sich die meisten Anfänger- fehler verhindern und man vermeidet, gleich für sein erstes Posting wegen formaler Fehler angeschnauzt zu werden. Falls du Fragen zu den Regeln im Usenet hast, stelle sie bitte in der Newsgroup <news:de.newusers.questions>. Weitere Links zum Thema: <URL:ftp://rtfm.mit.edu/pub/usenet/de.answers/de-newusers/> <URL:http://learn.to/quote/> 1.2. Worum geht es in dieser Newsgroup? Autor: Markus Reitz --------------------------------------- In der Newsgroup <news:de.comp.lang.java> sollen Probleme und Lösungen, die sich im Zusammenhang mit der Programmiersprache Java ergeben, diskutiert werden. Die Newsgroup beschäftigt sich nur mit der Sprache Java! JavaScript oder herstellerspezifische Implementierungen (z.B. Microsoft J++) besitzen eigene Newsgroups, in denen diese spezifischen Probleme und Lösungen diskutiert werden. Neben der Newsgroup <news:de.comp.lang.java> gibt es noch weitere (vor allem englischsprachige) Newsgroups, die sich mit der Programmiersprache Java beschäftigen. Siehe auch den Abschnitt "Themenverwandte Newsgroups". 1.3. Wie kommen häufig gestellte Fragen in diese FAQ? Autor: Uwe Günther ----------------------------------------------------- Nachdem man festgestellt hat, dass man in einem bestimmten Zyklus die gleiche Frage immer wieder mit der gleichen Antwort beantworten muss - nur weil die Unis ihren Lehrplan mal wieder geändert haben, in der c't mal wieder ein "Wie programmiere ich ein Applet"-Kurs unter die Leute gebracht wurde oder aus welchen Gründen auch immer - sollte man einen neuen Thread mit dem Subject: [FAQ] Neue Frage: <Frage> beginnen. Der Body dieser Nachricht sollte folgendes Format besitzen: --Schnipp-- Frage: <Frage> Antwort: <Antwort> Beispiel: <Code> --Schnapp-- Wobei der Text in spitzen Klammern, dein Part ist. Die Zeilenlänge darf 74 Zeichen nicht überschreiten. Der Code sollte die Code Conventions von Sun einhalten - wenn du nicht weisst was das ist, solltest du besser keine FAQ schreiben. Der gesamte Text darf keine Tabs enthalten und bei Bedarf gegen 4 Leerzeichen ersetzt werden. Es ist von grossem Vorteil wenn der Beispiel-Code kompilierbar ist. Das steigert die Qualität der FAQ ungemein. Nachdem der Thread dann von den Regulars und den anderen Lesern von de.comp.lang.java gebührend behandelt wurde und etwaige Probleme ausgeräumt wurden, muss die Endfassung des Textes an die im Header dieser FAQ angegebene e-mail Adresse des FAQ-Maintainers von de.comp.lang.java gesendet werden. Dabei ist es erwünscht die Rubrik, oder gleich die zukünftige Fragennummerierung mit anzugeben. Weiterhin muss die Message-ID mit angegeben werden, damit der FAQ-Maintainer überprüfen kann ob er nicht von irgendjemanden vereimert wird. ;-) 1.4. Wie kommen die Bugs aus der FAQ? Autor: Uwe Günther ------------------------------------- Nachdem man festgestellt hat, dass die FAQ einen Fehler hat, kann man diesen dem FAQ-Maintainer unter Angabe eines Workarounds direkt mitteilen. 1.5. TAGS-Konventionen zu einem einheitlichen Aussehen Autor: Markus Reitz -------------------------------------------------------- Neben den schon weiter oben genannten Ratschlägen, die allgemeine Anmerkungen zum Posten in Newsgroups darstellen, folgen nun einige spezifische Anmerkungen zur Schreibweise des Subjects in der Newsgroup <news:de.comp.lang.java>. Vor einiger Zeit wurde die Einführung sogenannter Tags vorgeschlagen, die die Übersichtlichkeit steigern sollen. Hintergrund ist die einfache Idee, den Inhalt des Postings durch ein eindeutiges Schlüsselwort, das Tag, zu charakterisieren. Mit einem entsprechend konfigurierten Newsreader ist es dann möglich, sich solche Nachrichten hervorheben zu lassen, wodurch man direkt auf einen Blick Postings beispielsweise zum Thema Swing überschauen kann. Tags werden an den Anfang des Subjects, in eckigen Klammern eingeschlossen, geschrieben. Damit Einheitlichkeit gewahrt wird, sollten die folgenden Tags verwendet werden. Wenn jeder seine eigenen Tags spezifizieren würde, wäre die Einheitlichkeit verloren und es würde genau-soviel Chaos wie vorher herrschen. Deshalb an dieser Stelle die Bitte, sich an die Vorgaben zu halten. Bei Änderungsvorschlägen bitte in die Newsgroup zur Diskussion posten und bei Akzeptanz in der Newsgroup werden die Vorschläge an dieser Stelle in die FAQ aufgenommen. Liste der Tags in <news:de.comp.lang.java>: Tags für Fragen: [LANG] - Frage bezüglich der Sprache Java. [STRING] - Fragen die unmittelbar mit Strings zu tun haben. [IO] - Frage bezüglich Eingabe/Ausgabe, Streams, etc. in Java. [NET] - Frage bezüglich Netzwerk. [AWT] - Frage bezüglich AWT. [SWING] - Frage bezüglich Swing. [APPLET] - Frage zu Java-Applets und ihre Zusammenarbeit mit Browsern. [SERVER] - Frage zu Servlets und anderen Server-Implementierungen in Java. [NONCORE] - Fragen zu Klassen/Packages, die über den Kern der Sprache hinausgehen, also Java3D etc. [OOP] - Frage bezüglich OOP-Konzepten und Patterns in Java. [JDK] - Frage zu virtuelle Maschinen, alles über JDKs und deren Installation und Verwendung. [TOOLS] - Frage zu einem Java-Zusatz-Tool, zum Beispiel IDEs, Build-Tools, Profiler, etc. [MATH] - Mathematik, Arithmetik, Gleitpunktzahlen, Funktionen. [MISC] - Alles, was nicht in eine der anderen Rubriken paßt. [ERROR] - Fragen zu Fehlermeldungen. [OT] - Alles was hochgrading off-topic ist und nicht direct mit Java zu tun hat. ;-) Tags "nicht"-Fragen: [INFO] - Allgemeine Informationen, z.B. Links auf Webseiten [DISCUSSION] - Diskussion zu einem Java-spezifischen Thema [ANNOUNCE] - Vorstellung neuer Software [PROST] - Darf nur von Regulars verwendet werden, die wissen was sie tun. ;-) 1.6. Ich bekam als Antwort auf meine Frage eine seltsame Buchstaben- kombination zugeschickt. Was ist das und wie kann ich es lesen? Autor: Stephan Menzel -------------------------------------------------------------------- Diese Kombination ist eine sogenannte Message-ID und bezeichnet einen Usenetartikel eindeutig. Vorgehensweise bei Message-ID-Angaben: (a) man hat einen Newsreader, der damit umgehen kann: - einfach draufklicken. (b) Wenn man Opera ab Version 6 verwendet, kann man in der Adressleiste einfach "r msgid:a2kpac.14g.1@aljoscha-rittner.de" eingeben und gelangt zur entsprechenden Seite von Google Groups. (c) ansonsten: http://groups.google.com, dann msgid:a2kpac.14g.1@aljoscha-rittner.de eingeben. (d) Wenn man gerne URLs bastelt: http://groups.google.com/groups?q=msgid:a2kpac.14g.1@aljoscha-rittner.de (e) oder http://groups.google.com/advanced_group_search dann Msg-ID bei "Beitrags-ID" eingeben. 2. Was man über Java wissen sollte ================================== 2.1. Was ist Java Autor: Markus Reitz ------------------------ Zuersteinmal: Java ist nicht JavaScript. JavaScript ist eine Sprache, die federführend von der Firma Netscape entwickelt wurde, um die Inhalte von Webseiten dynamischer und interaktiver zu gestalten. JavaScript-Programme werden in den HTML-Quelltext der Seite eingebettet und vom Browser interpretiert und ausgeführt. Zwar macht JavaScript viele Anleihen bei Java, ist aber bei weitem nicht so flexibel. Die deutsche Newsgroup zu JavaScript findet man unter: <news:de.comp.lang.javascript> Die Website von de.comp.lang.javascript ist unter folgendem Link zu finden: <URL:http://www.dcljs.de/> Java wurde von der Firma SUN Microsystems mit dem Ziel entwickelt, eine moderne, objektorientierte Sprache zu schaffen. Durch das Ziel der Plattformunabhängigkeit ist Java vor allem im Zusammenhang mit der Entwicklung von Web-Applikationen im Internet eine der am häufigsten verwendeten Sprachen. Doch Java beschränkt sich nicht nur auf das Erstellen von Effekten für die Webseite, Java ist eine ausgewachsene Programmiersprache, mit der man alle anstehenden Probleme lösen kann. Die Syntax der Sprache ist an die von C++ angelehnt, Schlüsselwörter sind verändert bzw. in der Bedeutung erweitert worden, bestimmte Features von C++ wurden zugunsten der Übersichtlichkeit bzw. Sicherheit nicht in Java verwendet. Java Programme liegen im sogenannten Bytecode vor, der Maschinencode für einen fiktiven Prozessor, der von der VM, der virtuellen Maschine, ausgeführt wird. Durch die Verwendung des Bytecodes wird die Plattformunabhängigkeit von Java garantiert - dieser Vorteil wird aber durch die, im Vergleich zu anderen Sprachen wie C++, wesentlich langsamere Ausführungsgeschwindigkeit bezahlt. 2.2. Verwandtschaft von Java mit anderen Sprachen? Autor: Markus Reitz ------------------------------------------------- Java bietet eine Reihe von neuen Features, orientiert sich aber auch an etablierten Sprachen wie C++, Smalltalk oder Objective-C. Prinzipien aus diesen Sprachen wurden übernommen und teilweise erweitert. Die folgende Tabelle gibt einen kleinen Überblick über Features von Java, die aus anderen Sprachen quasi "entliehen" wurden. |-----|-----------|-------------| | C++ | Smalltalk | Objective-C | |--------------------------------|-----|-----------|-------------| | Primitive Datentypen | * | | | |--------------------------------|-----|-----------|-------------| | Universelle Basisklasse Object | | * | | |--------------------------------|-----|-----------|-------------| | Garbage Collection | | * | | |--------------------------------|-----|-----------|-------------| | Konstruktoren | * | | | |--------------------------------|-----|-----------|-------------| | Statische Typen | * | | | |--------------------------------|-----|-----------|-------------| | Bibliothek von Standardklassen | | * | | |--------------------------------|-----|-----------|-------------| | Interfaces | | | * | |--------------------------------|-----|-----------|-------------| Im Vergleich zu C++ besitzt Java folgende Unterschiede: - noch keine Templates - keine Operatorenüberladung - kein prozeduraler Overhead - keine Mehrfachvererbung von Klassen 2.3. WebBrowser und Java Autor: Markus Reitz ------------------------ Java zählt immer noch zu den jüngeren Programmiersprachen und die Entwicklung verläuft in manchen Bereichen noch mit hoher Geschwindigkeit. Insbesondere Zusatz-APIs findet man inzwischen wie Sand am Meer und praktisch jede neue Version des JDK bietet Verbesserungen oder Erweiterungen der bestehenden APIs. Dies wird insbesondere dann problematisch, wenn man Java-Applets schreiben möchte, die in den bekannten Web-Browsern von Netscape oder Microsoft laufen sollen. Häufig werden aktuelle Features nur unzureichend oder gar nicht unterstützt. Deshalb sollte man folgendes beachten: - Ältere Webbrowser unterstützen (im günstigsten Fall) nur die Version 1.0 der Sprache - Neuere Webbrowser unterstützen zumindest teilweise die Sprachversion 1.1 (Netscape ab Version 4.04-J2, Microsoft Internet-Explorer ab Version 4.0) Um eine möglichst große Anzahl an Plattformen bedienen zu können, muß man sich also am besten auf Features der Sprache beschränken, die schon in der UrVersion vorhanden waren. Bei neueren Features läuft man Gefahr, daß Besitzer älterer Browser ausgeschlossen werden. Eine andere Alternative bietet die Verwendung des von SUN erhältlichen Java-Plug-In's. Dadurch werden ältere Browserversionen mit den Features der aktuellen Java-Version aufgerüstet, wodurch es dann sogar möglich wird, Java 2 - Programme in Browsern ablaufen zu lassen, obwohl diese die neueste Version ursprünglich noch gar nicht unterstützen. Das Plug-In ist auf der Homepage von SUN erhältlich, problematisch ist allerdings die Größe. Es ist daher fraglich, ob Benutzer bereit sind, sich wegen eines kleinen Homepage-Effektes ein großes Plug-In herunterzuladen. Sinn macht das Plug-In daher nur bei wirklich größeren Programmen oder bei Programmen, die für den Einsatz im Intranet ausgerichtet sind. 2.4. Erste Schritte in Java Autor: Markus Reitz --------------------------- Erfahrungen mit der Sprache Java zu sammeln ist nicht schwer. Sofern man einen Internetzugang hat, kann man sich die Sprachdefinition, Compiler etc. direkt von SUN besorgen. Es empfiehlt sich die Verwendung der Java-Implementierung von SUN, denn diese ist die Referenz für alle anderen Implementierungen und normalerweise die, die sich am aktuellsten Sprachstandard orientiert. Lösungen von Microsoft oder Symantec haben den Nachteil, daß Features modifiziert oder gar nicht implementiert werden oder Fähigkeiten hinzukommen, die der ursprünglichen Sprachimplementation fehlen. Außerdem bietet das JDK (Java Development Kit) von SUN den Vorteil, daß es kostenlos verfügbar ist. Nachteil: Compiler und Tools arbeiten kommandozeilenorientiert, d.h. man schreibt den Quellcode mit einem beliebigen Editor, speichert die Datei und führt dann den Compiler aus. Bei Fehlern lädt man die Datei, korrigiert den Fehler und das ganze Spiel beginnt von vorne. Abhilfe schaffen IDEs (Integrated Development Environment), die das JDK steuern und Fehler und andere Meldungen direkt anzeigen, ohne daß der Quelltexteditor verlassen werden muß. Ein weiterer Vorteil von IDEs ist das Feature Syntax Highlighting, das die Schlüsselwörter der Sprache farblich hervorhebt und dadurch die Übersichtlichkeit steigert. Bezugsquelle für das JDK: <URL:http://www.java.sun.com/j2se/> 2.5. Ich habe das HelloWorld-Programm aus meinem Java-Buch abgeschrieben, aber es funktioniert nicht. :-( Autor: Hubert Partl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Newbie: Ich habe das HelloWorld-Programm aus meinem Java-Buch abgeschrieben, aber es funktioniert nicht. :-( Oldie: Das ist schon richtig :-) so, das HelloWorld-Beispiel dient dazu, dass Du die typischen Anfaenger-Fehler kennenlernst und in Zukunft vermeiden kannst. In diesem Fall kann ich nur raten: Du hast wahrscheinlich einen der folgenden typischen Newbie-Fehler gemacht: * Du hast das Programm nicht genau genug abgeschrieben (Tippfehler, Gross-Kleinschreibung, Sonderzeichen, Leerstellen), lies doch die Fehlermeldungen und Korrekturhinweise, die der Compiler Dir gibt. * Du hast das Programm nicht unter dem richtigen Filenamen abgespeichert. Wenn die Klasse HelloWorld heisst, muss das File HelloWorld.java heissen, nicht helloworld.java und auch nicht HelloWorld.java.txt, im letzteren Fall versuch es mit notepad "HelloWorld.java" * Du hast beim Compiler nicht den kompletten Filenamen mit der Extension angegeben (wieder mit der richtigen Gross-Kleinschreibung): javac HelloWorld.java * Du hast bei der Ausfuehrung nicht den Klassennamen ohne die Extension angegeben (wieder mit der richtigen Gross-Kleinschreibung): java HelloWorld * In der Umgebungsvariable PATH ist das Directory, in dem sich die JDK-Software befindet, nicht neben den anderen Software-Directories enthalten, versuch set PATH=%PATH%;C:\jdk1.2\bin oder wie immer das auf Deinem Rechner heissen muss. * Die Umgebungsvariable CLASSPATH ist (auf einen falschen Wert) gesetzt. Diese Variable sollte ueberhaupt nicht gesetzt sein, nur in seltenen Spezialfaellen und dann so, dass sie sowohl die Stellen enthaelt, wo die Java-Klassenbibliotheken liegen, als auch den Punkt fuer das jeweils aktuelle Directory. * Du hast den Compiler nicht in dem Directory bzw. Folder aufgerufen, in dem Du das Java-File gespeichert hast. * Du hast ein Applet als Applikation aufgerufen, oder umgekehrt. Applikatonen, die eine main-Methode enthalten, musst Du mit java Classname aufrufen. Applets, die ein "extends Applet" oder "extends JApplet" enthalten, musst Du innerhalb eines geeigneten HTML-Files mit appletviewer xxxxx.html oder mit Netscape oder Internet-Explorer aufrufen. Mehr darueber findest Du in meiner Java-Einfuehrung auf <URL:http://www.boku.ac.at/javaeinf/jein1.html#software> Aehnliche Hinweise findest Du im Java Glossary von Roedy Green auf <URL:http://mindprod.com/gloss.html> 3. Häufig gepostete Fragen ========================== 3.1. [LANG] - Frage bezüglich der Sprache Java. ----------------------------------------------- 3.1.1. Gibt es in Java keine Zeiger wie in C++? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Im Prinzip gibt es ein Konstrukt, das den Zeigern anderer Programmiersprachen, wie zum Beispiel C++, sehr ähnlich ist: die sogenannten Referenzen. Referenzen können, im Vergleich zu Zeigern in C++, nicht manipuliert werden; die sogenannte Zeigerarithmetik, bei der man Zeiger auf beliebige Speicherinhalte zeigen lassen kann, wurde aus Sicherheitsgründen nicht in Java übernommen. Der Inhalt einer Referenz kann einer anderen Referenz zugewiesen werden, Referenzen können miteinander verglichen werden. Wird in Java eine Objektvariable angelegt, so ist dies nichts weiter als ein Speicherplatz für eine Referenz für ein Objekt des angegebenen Typs. Der new-Operator erzeugt das eigentliche Objekt und liefert die Referenz darauf zurück, die dann in der Objektvariablen gespeichert wird. 3.1.2. Warum ist Referenz nicht gleich Referenz? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem: public class Test { public static void main (String[] args) { String a = "A"; String x = a; System.out.println(x); a = "B"; System.out.println(x); } } Die Ausgabe sollte doch eigentlich so aussehen: A B Denn die Variable x speichert doch eine Referenz auf den String a! Im ersten Fall hat a den Wert A und damit auch x, das ja auf diesen String verweist. Im zweiten Fall wird a geändert und damit müßte sich doch auch eigentlich der Wert von x ändern, weil x auf a verweist. Die Ausgabe, die das Programm liefert, ist jedoch: A A was eigentlich nicht in das Bild einer normalen Referenz passt. Ursache: Der Fehler liegt darin begründet, daß a nicht der eigentliche String ist, sondern nur eine Referenz auf diesen String. Durch x = a referenzieren beide Variablen den selben String und durch a = "B" verweist a auf einen anderen neuen String mit dem Wert B. Dies ändert jedoch nichts an der Referenz, die in x gespeichert ist. Somit ist die Ausgabe völlig korrekt. 3.1.3. Wie werden in Java Funktionsparamter übergeben, by value oder by reference? Autor: Paul Ebermann ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Java kennt (genauso wie C, aber im Gegensatz zu etwa Pascal) kein "Call by Reference". Wenn Objekte als Parameter verwendet werden, wird eben die Referenz "by Value" übergeben. Somit kann man zwar das Objekt (so es veränderbar ist) verändern, aber nicht die originale Variable, die als Parameter verwendet wurde. Beispiel für Call by Reference: (Pascal - [Syntax bestimmt nicht korrekt]) program ReferenzTest(input, output); var x, y : integer; procedure swap (var a: integer; var b: integer); var h : Integer; begin h := a; a := b; b := h; end; begin x := 1; y := 2; swap(x,y); writeLn('x = ', x, ', y = ', y , '.'); end. Das Programm gibt am Ende x = 2 und y = 1 aus. In Java geht das nicht: package de.dclj.faq; class CallByReferenceTest { static void swap (int a, int b) { int h = a; a = b; b = h; } public static void main(String[] test) { int x = 1; int y = 2; swap(x,y); System.out.println("x = " + x + ", y = " + y); } } Zur Call-by-Reference-Simulation bietet sich die Verwendung von Arrays an - da diese Objekte sind, wird ja nur die Referenz übergeben. class CallByReferenceSimulation { static void swap(int[] a, int[] b) { int h = a[0]; a[0] = b[0]; b[0] = h; } public static void main(String[] test) { int[] x = {1}; int[] y = {2}; swap(x,y); System.out.println("x = " + x[0] + ", y = " + y[0]); } } Einen etwas anderen Blickwinkel zu diesem Thema bietet die Webseite: <URL: http://purl.net/stefan_ram/pub/java_referenzvariablen_als_argument_de> 3.1.4. Warum gibt es in Java keine Destruktoren wie in C++? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In Java hat der Programmierer unter normalen Umständen keinen direkten Einfluß darauf, wann Objekte aus dem Speicher entfernt werden. So ist es unter anderem nicht möglich, ein Objekt per Befehl aus dem Speicher zu löschen. Dies erledigt der sogenannte Garbage-Collector, der Objekte aus dem Speicher entfernt, auf die keine Referenz mehr verweist. Dadurch wird verhindert, daß der Programmierer mehr oder minder mutwillig Speicherfehler erzeugen kann, die das Programm zum Absturz bringen könnten. Wann die Entfernung aus dem Speicher erfolgt, liegt im Ermessen des Computers. Es gibt also keinen definierten Zeitpunkt, wann ein Objekt nicht mehr existiert und deshalb ist es in den meisten Fällen nicht sinnvoll, Operationen zu definieren, die beim Löschen des Objektes ausgeführt werden. Man könnte (ungültige) Annahmen voraussetzen - zum Beispiel bei verketteten Listen, daß das Nachfolgerelement noch existiert, obwohl dies gar nicht der Fall ist - und damit Fehler verursachen. Destruktoren wie in C++ existieren deshalb nicht. Ist es aus irgendeinem dringenden Grund dennoch nötig, Operationen beim Löschen des Objektes auszuführen, so kann man eine Methode finalize definieren, die bei der Speicherbereinigung abgearbeitet wird. Wobei nicht garantiert wird die finalize methode überhaupt von der JVM abgearbeitet wird. 3.1.5. Warum funktioniert die equals Methode nicht? Autor: Markus Reitz Autor: Martin Erren ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem 1: Man hat eine eigene Klasse entworfen und möchte nun testen, ob zwei Objekte gleich sind. Fein, denkt man sich, dafür bietet die Klasse Object ja die Methode equals(Object obj). Doch das Programm mit Verwendung der equals(Object obj) Methode wird zwar korrekt übersetzt, der Vergleich funktioniert jedoch nicht so, wie er eigentlich sollte. Per Default sagt equals(), dass es sich um die selbe Instanz einer Klasse handelt: public class Object { ... public boolean equals(Object other) { return this == other; } ... } Lösung 1: Die Methode equals(Object obj) muß für jede Klasse neu überschrieben werden. Schließlich kann man nicht in allgemeiner Weise die Gleichheit zweier Objekte einer Klasse spezifizieren. Das ist insbesondere dann wichtig falls die Objekte in einer Set oder als Keys für eine Map verwendet werden. Dann muss allerdings auch die Methode hashCode() überschrieben werden. Siehe dazu auch die nächste Frage in dieser FAQ! Dazu sollte man sich auf alle Fälle in der JavaDoc zu Object, speziell die Methoden hashCode() und equals(Object obj) ansehen: <URL:http://java.sun.com/j2se/1.4/docs/api/java/lang/Object.html> Für Strings beispielsweise sind equals() und hashCode() bereits überschrieben. So dass String-Objekte als Keys verwandt werden können. Problem 2: public class Test { private int a; private int b; public Test (int a , int b) { this.a = a; this.b = b; } public boolean equals(Test other) { return (this.a == other.a) && (this.b == other.b); } } Verwendet man nun Objekte dieser Klasse in Containerklassen und hier insbesondere Methoden, die auf die Methode equals des Objekts zurückgreifen, so funktioniert dies nicht. Der Grund liegt in der falschen Signatur der Methode equals. Der Parameter muß vom Typ Object sein und nicht vom Typ der Klasse, zu dem die Methode gehört. Ansonsten existieren für die Klasse Test zwei Versionen der equals Methode: Eine, die von der Klasse Object geerbt wurde und die als Parametertyp auch Object besitzt und als zweite die oben definierte. Containerklassen verwenden aber die erste und da diese nicht verändert wurde, wird nicht das gewünschte Ergebnis erzielt. Lösung 2: public class Test { private int a; private int b; public void Test (int a , int b) { this.a = a; this.b = b; } //Die hash-Funktion ist aus dem Buch "Effective Java" von //Joshua Bloch. public int hashCode() { int result = 17; result = 37*result + this.a; result = 37*result + this.b; return result; } public boolean equals(Object obj) { //Für eine bessere Performance. if (this == obj) { return true; } //Wenn (obj == null) dann gibt instanceof false zurück //Siehe JLS 15.20.2 if (!(obj instanceof Test)) { return false; } Test other = (Test)obj; return (this.a == other.a) && (this.b == other.b); } } 3.1.6. Wenn ich eigene Objekte mit einer Hashtable/HashMap verwalte, kommt es zu sonderbaren Effekten. Wieso? Autor: Ingo R. Homann, Gerhard Bloch ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Damit eigene Objekte als Schluessel in einer Hashtable/HashMap funktionieren, muessen zwei Bedingungen erfuellt sein: 1. Wenn man die equals-Methode einer Klasse überschreibt, sollte man beachten, dass man auch die hashCode-Methode überschreiben muß! 2. Nichts, was equals-Vergleiche beeinflusst, darf geaendert werden, waehrend das Objekt in einer Hashtable/HashMap ist! Insbesondere darf sich der Hashcode nicht aendern. Man muss sicherstellen, dass Objekte, die laut der equals-Methode gleich sind, auch einen identischen Hashcode haben müssen. Der Umkehr-Schluss, dass ungleiche Objekte (bei denen equals false liefert) zwangsläufig auch unterschiedliche Hashcodes haben müßen, gilt nicht. Trotzdem sollte man als Programmierer versuchen, möglichst darauf hinzuarbeiten (und keineswegs z.B. für alle Objekte einen gleichen, konstanten Hashcode liefern!), damit die Implementierungen von Hashtable und HashMap effizient arbeiten können. Als Folge dieser Forderung sollten zur Berechnung des Hashcode genau die Attributwerte einbezogen werden, die auch zur equals-Bestimmung verwendet werden, insbesondere aber keine anderen Werte! Die Forderung kann auch so formuliert werden: a.equals(b) => (a.hashCode() == b.hashCode()) oder (a.hashCode() != b.hashCode()) => !a.equals(b) Eine Hashtable funktioniert vereinfacht folgendermassen: Die Schluessel-Wert-Paare werden beim Einfuegen in Buckets ("Eimer") verteilt. Dabei entscheidet der Hashcode des Schluessels, in welchen Bucket er kommt. Beim Suchen wird anhand des Hashcodes des Suchschluessels der Bucket ermittelt, in dem das gesuchte Objekt liegen muss. So können (außer in ungünstigen Fällen) fast alle Schluessel der Tabelle ausgeschlossen werden, der Suchschluessel muss nur noch innerhalb des Buckets gesucht werden; falls er (genauer: ein Schluessel, dessen equals-Vergleich mit dem Suchschluessel true ergibt) dort gefunden wird , wird der Wert zurueckgegeben. Dies funktioniert deshalb, weil aufgrund der obigen Forderung nur diejenigen Objekte uebereinstimmen koennen, die auch im Hashcode uebereinstimmen (equals => gleicher Hashcode). Ein Problem ergibt sich, wenn nach dem Einfuegen ein Schluessel geaendert wird. Da sich dadurch auch dessen Hashcode (mit ziemlicher Sicherheit) aendert, liegt er nun im falschen Bucket. Die Hashtable bekommt von der Aenderung ja nichts mit! Deshalb ist zu beachten, dass sich Schluessel nicht aendern, solange sie in einer Hashtable verwendet werden. Sichergestellt werden kann dies nur durch immutalbe Objekte (siehe 3.10.7). Beispiel fuer das richtige Ueberschreiben von hashCode: public class Name { private static int zaehler= 0; private String vorname private String nachname; private final int id = zaehler++; public Name(String vorname, String nachname) { this.vorname = vorname; this.nachname = nachname; } public boolean equals(Object o) { // die id ist nur fuer interne Zwecke und hat keinen Einfluss // auf Gleichheit if(o instanceof Name) { Name n = (Name)o; return vorname.equals(n.vorname) && nachname.equals(n.nachname); } else { return false; } } public int hashCode() { // Es werden genau die Werte einbezogen, die auch in der // equals-Methode verwendet werden int result = 17; result = 37*result + vorname.hashCode(); result = 37*result + nachname.hashCode(); return result; } } 3.1.7. Was bedeutet das Schlüsselwort final? Orginalautor: Markus Reitz Autor: Paul Ebermann ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Klassen oder Methoden, die das Schlüsselwort final tragen, können nicht mehr überschrieben werden, wenn von dieser Klasse abgeleitet wird. Die Verwendung dieses Schlüsselwortes bietet sich aus zwei Gründen an: - Realisierung von Sicherheitsmaßnahmen - Codeoptimierung Sicherheitsmaßnahmen werden realisiert, weil es nicht möglich ist, die Bedeutung der Methode in abgeleiteten Klassen zu verändern und damit bestehende Konzepte zu durchbrechen. Codeoptimierung deshalb, weil der Compiler nun davon ausgehen kann, daß sich an den Methoden nichts mehr ändern wird und deshalb elegantere Codeoptimierungen möglich sind. In Anbetracht der Tatsache, daß final-Methoden nicht mehr verändert werden können, muß man sich beim Programmentwurf sehr sicher sein, daß das Feature des Überschreibens definitiv nicht für diese Methode benötigt wird, ansonsten kann es bei Verbesserungen des Codes zu Problemen kommen. Wenn Variablen mit dem Schlüsselwort final deklariert werden, hat das zur Folge, dass ihr Wert nur einmal zugewiesen (initialisiert) und dann nicht mehr verändert werden kann. Wenn der Compiler das nicht nachweisen kann, gibt es einen Fehler. * Bei Exemplarvariablen kann die Zuweisung direkt in der Deklaration, in einem Initialisierungsblock oder in (dann allen) Konstruktoren erfolgen. Bei Klassenvariablen kann die Zuweisung direkt in der Deklaration oder in einem Klassen-Initialisierungsblock erfolgen. * Bei lokalen Variablen muss die Zuweisung in der Deklaration oder irgendwo später im Code, jedenfalls vor dem ersten Lese-Zugriff erfolgen. * Bei Methoden- oder Konstruktor-Parametern mit final kann keine Zuweisung erfolgen. 3.1.8. Warum wird der dynamische Parametertyp bei überladenen Funktionen nicht beachtet? Autor: Uwe Günther, Erwin Hoffmann, Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Dies ist ein korrektes Verhalten gemäß der Java-Sprachspezifikation! Die Entscheidung, welche überladene Methode bei der Übergabe eines bestimmten Parameters auszuwählen ist, wird nicht anhand des Typs des an die Methode übergebenen Objekts getroffen, sondern anhand des Typs der Referenz, die auf das übergebene Objekt verweist. Diese Entscheidung wird vom Compiler getroffen. Hier muss also zur Compilezeit entschieden werden, welche Methode aufgerufen werden soll. Der Compiler kann sich nur auf den Referenztyp beziehen, weil der Objekttyp nur dynamisch zur Laufzeit eines Programms festgestellt werden kann. Das Ganze demonstriert ein Beispielprogramm: public class BasisKlasse {} public class AbgeleiteteKlasse extends BasisKlasse {} public class Test { public static void methode(BasisKlasse eineKlasse) { System.out.println("Methode mit BasisKlasse!"); } public static void methode(AbgeleiteteKlasse eineKlasse) { System.out.println("Methode mit AbgeleiteteKlasse!"); } public static void testMethode(BasisKlasse a) { if (a instanceof AbgeleiteteKlasse) { System.out.print("Abgeleitet: "); } else { System.out.print("Basis: "); } //Welche Methode wird jetzt gerufen? methode(a); } public static void main (String[] params) { BasisKlasse a = new BasisKlasse(); AbgeleiteteKlasse b = new AbgeleiteteKlasse(); testMethode(a); testMethode(b); } } Das Programm erzeugt folgende Ausgabe: Basis: Methode mit BasisKlasse! Abgeleitet: Methode mit BasisKlasse! 3.1.9. Was bedeutet super()? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Werden Ableitungen von Klassen gebildet und dabei Funktionen redefiniert (überschrieben), so ist es in vielen Fällen nötig, auf die Funktionalität der Basisklasse zurückzugreifen. Mit super.methode() teilt man mit, daß man die Methode der Basisklasse und nicht die Methode der aktuellen Klasse benutzen will. Innerhalb eines Konstruktors ist es möglich mit super() den Konstruktor der Basisklasse aufzurufen. Findet im Konstruktor kein expliziter Aufruf mit super() statt, so wird automatisch der parameterlose Konstruktor (Standardkonstruktor) der Basisklasse aufgerufen. 3.1.10. Was sind anonyme Arrays? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ab Java 1.1 ist folgender Code gültig: int i[]; i = new int[] {1, 2, 3}; Es ist jetzt also möglich, Arrays auch außerhalb der Definition mit den gewünschten Werten zu initialisieren, indem man mit {...} einfach die Werte angibt, die das neue Array tragen soll. 3.1.11. Gibt es in Java einen Prä-Prozessor wie in C++? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Nein. In C++ existiert der sogenannte Prä-Prozessor, der es mit bestimmten Kommandos erlaubt, Teile des Codes zu übersetzen und andere Teile bei der Übersetzung zu überspringen. Unter Umständen wäre es hilfreich, wenn auch Java eine solche Möglichkeit der Compilationssteuerung zulassen würde, doch einen Prä-Prozessor gibt es hier nicht. Man kann dies aber, zumindest ansatzweise, mit if-Statements nachbilden. Dazu definiert man eine boolesche Variable DEBUG und in Abhängigkeit von dieser Variablen sollen bestimmte Codeteile ausgeführt werden, andere dagegen nicht. public class Test { final static boolean DEBUG = true; public static void main (String[] params) { int i = 12; if (DEBUG) { System.out.println("Der Wert von i ist " + i); } } } Verwendet man nun noch Optimierer, die unbenutzten Code aus den Klassendateien entfernen, so hat man im Prinzip ein ähnliches Verhalten wie beim Prä-Prozessor von C++. In diesem Zusammenhang ist es noch erwähnenswert, daß das Verfahren nur bei der if-Abfrage möglich ist, denn das Java-System prüft normalerweise darauf, ob Codezeilen erreicht werden können oder nicht und gibt gegebenenfalls Fehlermeldungen aus. Das if-Statement ist jedoch wie oben beschrieben erweitert worden, um das gewünschte Verhalten simulieren zu können. Dahingegen wird folgender Code mit einer Fehlermeldung quittiert: public class Test { final static boolean DEBUG = true; public static void main (String[] params) { int i = 12; while (DEBUG) { System.out.println("Der Wert von i ist " + i); } } } Denn es würde sich je nach Zustand von DEBUG eine Endlosschleife ergeben. 3.1.12. Existiert der const Modifizierer von C++ auch in Java? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ kennt das Schlüsselwort const, das es erlaubt, konstante Objekte zu definieren, deren Wert man nicht ändern kann. Auf ein solches Objekt kann man nur Methoden anwenden, die ebenfalls als const definiert sind, die also die Daten des Objektes nicht ändern können. Ab Java 1.1 können Argumente mit dem Modifizierer final als konstant definiert werden. Bei einer Objektreferenz bedeutet dies allerdings nur, daß die Referenz konstant bleibt, nicht aber das Objekt, auf das die Referenz verweist. Da Java den Modifizierer const nicht kennt, ist es aber trotzdem recht einfach möglich, diesen nachzubilden. Alles, was man dazu braucht, ist ein Interface, das die konstanten Methoden enthält, die das Objekt nicht ändern können. Will man nun ein konstantes Objekt zurückgeben oder erzeugen, dann gibt man einfach eine Referenz vom Typ des Interfaces zurück und schon hat man das Gewünschte erzielt. Folgendes Beispiel soll das Ganze etwas verdeutlichen: interface KonstanterTyp { public int get(); } public class NichtKonstanterTyp implements KonstanterTyp { int i; public void set(int i) { this.i = i; } public int get() { return this.i; } } Ein konstantes Object wird dann durch KonstanterTyp A = new NichtKonstanterTyp(); erzeugt. Anmerkung: Im Prinzip wird hier durch das Interface eine Art Untermenge der Klasse NichtKonstanterTyp definiert. Bei C++ läuft dieser Prozeß im Prinzip auch so ab, nur wird hier vom Compiler automatisch diese Untermenge durch den Modifizierer const erzeugt und der Programmierer muß sich hierum nicht kümmern. In Java muß man diesen Prozeß selbst durchführen. 3.1.13. Wie kann man Referenzen von Übergabeparametern ändern? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Von Sprachen wie C++ oder Pascal kennt man die Möglichkeit, Referenzen, die an die Methode übergeben werden, innerhalb der Methode zu ändern, an die sie übergeben wurden, wodurch nach dem Aufruf der Methode die Referenzen auf andere Objekte verweisen. In Java gibt es zwei Möglichkeiten, diesen Effekt zu erreichen: - Einführen einer weiteren Ebene mit Wrapper-Klassen, die spezielle Referenzen zur Verfügung stellen. - Verwendung von eindimensionalen, einelementigen Arrays. Der erste Punkt dürfte klar sein, jedoch steht der Aufwand erst dann in einem vernünftigen Verhältnis zum Ergebnis, wenn diese Art der Parametermodifikation öfter innerhalb des Programms vorkommt, denn ansonsten lohnt sich das Design einer speziellen Klasse nicht unbedingt. Den zweiten Weg verdeutlicht das folgende Programm: public class Test { public void parameterModifikation(Object[] paramter) { parameter[0] = "Neue Referenz"; } public static void main (String[] args) { Objcet parameter[] = new Object[1]; parameter[0] = "Zu modifizierender Parameter." Test test = new Test(); System.out.println(parameter[0]); test.parameterModifikation(parameter); System.out.println(parameter[0]); } } Das Beispielprogramm liefert folgende Ausgabe: Zu modifizierender Parameter Neue Referenz 3.1.14. Wie erzeuge ich eine tiefe Kopie eines Objektes mit möglichst wenig Aufwand? Autor: Markus Reitz Autor: Ingo R. Homann ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Weist man einer Objektvariablen eine andere zu, so wird nur die Referenz kopiert und beide Objektvariablen können das Objekt modifizieren und diese Modifikation auch sehen. Dies ist das Standardverhalten von Java. Durch clone() wird z.B. eine flache Kopie von dem Vector angelegt, d.h. z.B. das Hinzufügen eines neuen Elements in die Kopie des Vektors ist im Original-Vector nicht sichtbar. Die enthaltenen Objekte jedoch werden *nicht* mitkopiert, d.h. Änderungen an den enthaltenen Objekten sind in beiden Vectoren sichtbar. Wenn wirklich alles - also auch die enthaltenen Objekte und die rekursiv darin enthaltenen Objekte - kopiert werden soll, dann braucht man eine sog. tiefe Kopie. Ein sehr eleganter Weg, eine tiefe Kopie eines Objektes zu erzeugen, verwendet den Serialisierungs-Mechanismus. Objekte, die man mit diesem Verfahren kopieren möchte, müssen also das Interface Serializable implementieren. import java.io.ByteArrayOutputStream; import java.io.ByteArrayInputStream; import java.io.ObjectOutputStream; import java.io.ObjectInputStream; import java.io.IOException; public class TiefeKopie { public static Object kopiere(Object einObjekt) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(baos); oos.write(einObjekt); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bais); return ois.readObject(); } } Zuerst werden zwei Ausgabeströme angelegt: Ein Byte-Strom und ein Object-Strom. Der Byte-Strom wird hinter den Object-Strom geschaltet und das zu kopierende Objekt wird auf dem Object-Strom ausgegeben und durch die Verknüpfung der beiden Ströme schließlich in den Byte-Strom geschrieben. Dieser Byte-Strom wird dann mit einem zweiten Strom wieder eingelesen und mit einem weiteren Object-Strom wird aus den einzelnen Bytes wieder ein Objekt rekonstruiert. Die Ausgabe des Object-Stroms ist dann das kopierte Objekt. Die Anwendung der Klasse zeigt folgendes Codefragment: public class Test { public static void main(String[] args) { int einArray[] = {56, 42, 67, 90, 12, 45}; int tiefeKopieVonEinArray = (int[]) TiefeKopie.kopiere(einArray); } } Ein Array ist in Java nichts weiteres als ein Objekt und implementiert auch das Serializeable-Interface, weshalb das obige Kopierverfahren problemlos greifen kann. Anmerkung: Bei komplexen Objekten, die viele Referenzen auf andere Objekte besitzen schlägt das Verfahren meist fehl. Der Serialisierungsmechanismus verwendet Rekursion, um alle referenzierten Objekte zu speichern. Wird auf Objekte referenziert, die wieder auf Objekte referenzieren usw. kann es geschehen, daß der Stack-Speicher für die Rekursion überläuft. Diese elegante Methode der tiefen Kopie kann also nur bei einfachen Objekten angewendet werden. In Sachen Performance liegt diese Lösung jedoch um einiges hinter der klassischen Lösung alle Elemente einzeln zu kopieren. Dessen sollte man sich klar sein, wenn man diese Lösung einsetzt. 3.1.15. Wie kann ich in Java eine dem Programmierer unbekannt Anzahl gleichartiger Objekte erzeugen und ihnen passende Namen zuweisen, also label1, label2 usw.? Autor: Michael Paap, Christian Kaufhold ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das ist in dieser Form nicht sinnvoll. Die bessere Lösung besteht in der Verwendung eines Arrays. In Java kann die Größe eines Arrays bei seiner Erzeugung zur Laufzeit (einmalig!) festgelegt werden. Ein Zugriff auf die einzelnen Objekte erfolgt dann über den Arrayindex: // Deklaration Label[] myLabels; ... // Erzeugung und Initalisierung zur Laufzeit int anzahl = 10; myLabels = new Label[anzahl]; for (int i = 0; i < myLabels.length; i++) { myLabels[i] = new Label("Label Nr. " + i); } // Verwendung myLabel[3].setBackground(Color.red); 3.1.16. Wie kann ich den Typ enum aus C++ in Java umsetzen? Autor: Markus Reitz, Uwe Günther, Ulf Jährig ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C++ bietet einen sogenannten Enumerationstyp. Eine Variable eines solchen Typs kann nur definierte Werte annehmen, die mit symbolischen Namen bezeichnet werden. Folgende Enumeration könnte zum Beispiel für eine Ampel verwendet werden: enum Ampel {ROT, GELB, GRUEN}; Java bietet diesen Typ nicht, kann diesen aber recht einfach mit einem Interface nachbilden: interface Ampel { public static final int ROT = 1; public static final int GELB = 2; public static final int GRUEN = 3; } Ein C++ Compiler führt automatisch die Zuordnung von Variablennamen zu eindeutigen Zahlenwerten durch, in Java muß der Programmierer diesen Prozeß erledigen. Die Verwendung differiert zwischen Java und C++: Ampel eineVariable = ROT; // Das ist C++ int eineVariable = Ampel.ROT; // Das ist Java Man erkennt einen großen Nachteil der Java-Version: Da es sich um eine int-Variable handelt, ist es prinzipiell möglich, jeden Wert an diese Variable zuzuweisen, eben nicht nur Werte aus dem Wertebereich rot, gruen und gelb. Im Gegensatz dazu läßt ein C++-Compiler nur Zuweisungen von Symbolen aus dem Enumerationstyp zu. Insofern ist die Nachbildung in Java weniger sicher als das C++-Pendant und sollte daher mit Vorsicht angewendet werden. Sprich sie ist nicht Typsicher! Wie schon oben angesprochen, bietet diese direkte Implementierung den Nachteil, daß sie nicht typsicher ist. Doch es ist recht einfach möglich, mit Java eine typsichere Implementierung zu erhalten: public final class Ampel { private String name; public final int ord; private static int obereGrenze = 0; private Ampel(String name) { this.name = name; this.ord = obereGrenze++; } public String toString() { return this.name; } public static int groesse() { return this.obereGrenze; } public static final Ampel ROT = new Ampel("Rot"); public static final Ampel GELB = new Ampel("Gelb"); public static final Anpel GRUEN = new Ampel("Gruen"); } Besonders interessant ist hier die Kombination von automatischer Zuweisung eines eindeutigen Zahlenwertes mit den Symbolwerten eines Strings. Auf den ersten Blick sieht die Klassendefinition ziemlich kompliziert und unverständlich aus, das Prinzip ist jedoch nicht schwer zu verstehen: - Zuersteinmal ist die Klasse als final deklariert, wodurch verhindert wird, daß von dieser Klasse Ableitungen gebildet werden können. Der Aufzählungstyp kann also - weder absichtlich noch unabsichtlich - durch Vererbung verändert werden. - Der Konstruktor der Klasse ist private, dadurch kann er nur von der Klasse selbst aufgerufen werden. Damit sind die einzigen Instanzen, die von Ampel erzeugt werden können, die, die den public-Variablen der Klassen zugewiesen sind. - Einer Referenz vom Typ Ampel können durch diese Maßnahmen nur die Werte {ROT, GELB, GRUEN} zugewiesen werden, andere Instanzen vom Typ Ampel sind ausgeschlossen, weil sie niemals existieren werden. - Die Überlagerung von toString hat den Zweck, einem das Leben beim Debuggen einfacher zu machen. Will man nun diesen Typ von Enumeration benutzen, so sieht das in etwa wie folgt aus: public class Test { public static void main(String[] args){ Ampel meineAmpel = Ampel.ROT; if (meineAmpel == Ampel.ROT) { System.out.println("Ampel ist " + meineAmpel + ". "); System.out.println("Anhalten!"); } if (meineAmpel == Ampel.GELB) { System.out.println("Ampel ist " + meineAmpel + ". "); System.out.println("Motor starten -oder- Anhalten!"); } if (meineAmpel == Ampel.GRUEN) { System.out.println("Ampel ist " + meineAmpel + ". "); System.out.println("Gib Gas!"); } } } Dieser Typ der Enumeration verwendet also Referenzen und nicht, wie Version 1, int-Werte, die nicht typsicher sind. Durch die Typprüfungsmechanismen von Java wird diese Art von Enumeration vollkommen typsicher und steht dem enum Konstrukt von C++ nun in nichts mehr nach. Wer mehr über dieses Pattern erfahren möchte sei dem sei folgender Link empfohlen: <URL:http://www.javaworld.com/javaworld/jw-07-1997/jw-07-enumerated.html> 3.1.17. Kann man Mehrfachvererbung mit Java simulieren? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Java kennt im Gegensatz zu C++ nicht das Feature der Mehrfachvererbung, eine Klasse kann nur genau einen Vorfahren haben, im Gegensatz zu beliebig vielen bei Mehrfachvererbung. Häufig liest man, daß man die Mehrfachvererbung mit Hilfe von Interfaces nachbilden kann, indem man die Methodenschnittstelle der einzelnen Klassen als Interfaces definiert und diese Interfaces alle gleichzeitig von der fraglichen Klasse implementieren läßt, denn dies ist in Java möglich. Mit Mehrfachvererbung hat dies aber nichts zu tun, wenn man den eigentlichen Sinn und Zweck von Vererbung betrachtet. Vererbung ist eines der möglichen Prinzipien, um die Codewiederverwertung zu garantieren. Code, der in mehreren Klassen benötigt wird, ist nur in der Basisklasse aufgeführt und durch die Vererbung können die Erben auch diesen Code benutzen. Der Code steht also nur an einer Stelle. Bei der oben beschriebenen Nachbildung wird in keiner Weise Code gespart, denn die Methoden der Interfaces müssen ja von der Klasse noch implementiert werden. In diesem Sinne kann man Mehrfachvererbung nicht in Java nachbilden. 3.1.18. Wie realisiere ich eine variable Parameterliste? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Es gibt Anwendungsfälle, in denen es äußerst nützlich wäre, einer Methode eine variable Anzahl an Parametern übergeben zu können. Ein Anwendungsfall wäre eine Klasse beliebig-dimensionaler Vektoren. Ein Konstruktor dieser Klasse müßte die Initialisierung eines Vektors mit bestimmten Werten erlauben und da beliebig-dimensionale Vektoren von dieser Klasse verarbeitet werden, müßte der Konstruktor mit einer variablen Parameteranzahl arbeiten können. Mit einem Trick kann man eine variable Parameterliste realisieren: Man übergibt der Methode ein Array von Referenzen auf die Klasse Object. Da in Java alle Objekte von der Klasse Object abstammen - sie ist quasi die Klasse aller Klassen - kann das Array Referenzen auf beliebige Objekte aufnehmen. Innerhalb der Methode kann dann mit dem length-Feld des Arrays die Anzahl der übergebenen Parameter ermittelt werden. Mit dem instanceof-Operator von Java kann dann der Typ des Objekts ermittelt werden, auf den die Referenzen verweisen und an Hand dieser Informationen kann man dann festlegen, was getan werden soll. Ein Programmfragment verdeutlicht das bisher Gesagte: public class Test { void methodeMitVariablerParameterListe(Object[] parameterList) { //Länge: parameterList.length ===> Anzahl der Parameter //Typ: if (parameterList[i] instanceof <Type>) } } Ein Nachteil ist offensichtlich: Es kann nur genau eine Methode mit variabler Parameterliste geben bzw. innerhalb dieser einen Methode müssen alle Variationen berücksichtigt und implementiert werden, was nicht unbedingt zur Übersichtlichkeit des Programms beiträgt. Ein Aufruf der Methode gestaltet sich nun wie folgt: Test obj = new Test(); obj.methodeMitVariablerParameterListe(new Object[] { paramObject1, paramObject2, ..., paramObjectn }); Will man elementare Datentypen wie double oder int an die Methode übergeben, so muß man die zugehörigen Wrapper-Klassen verwenden, die diese elementaren Datentypen in Klassen einpacken. 3.1.19. Wie realisiere ich eine Methodenauswahl nach den dynamischen Parametertypen? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Java wählt Methoden nach dem statischen Typ der Übergabeobjekte aus. Man kann jedoch eine dynamische Auswahl simulieren, indem man das oben angesprochene Prinzip der variablen Parameter hierauf überträgt. Man prüft die übergebenen Referenzen mit dem instanceof-Operator, der den dynamischen Typ des Parameters liefert. Anhand dieser Informationen kann man dann ein dynamisches Verhalten der Methodenaufrufe realisieren. Auch hier gilt, wie auch schon bei der variablen Parameterliste, daß eine einzige Methode alle Aufrufmöglichkeiten abdecken muß. 3.1.20. Sind Methoden in Java immer virtuell? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In Java sind alle Methoden virtuell, eine Unterscheidung zwischen virtuellen und nicht-virtuellen Methoden wie zum Beispiel in C++, gibt es in Java nicht. Ist es für die Funktionsweise eines Objektes wichtig, daß die vorhandenen Methoden nicht überschrieben werden können - etwa um zu verhindern, daß sich die Funktionalität des Objekts dadurch grundlegend ändern läßt - so muß man entsprechende Methoden mit dem Modifizierer final deklarieren, der ein Überschreiben verhindert. 3.1.21. Ich stosse ab und zu auf den Begriff "Wrapper-Klassen". Könnte mir jemand erklären was das ist? Autor: Stephan Menzel ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Eine sehr gute Frage, auf die ich mal mit einem Zitat aus Go to Java 2 antworten moechte, denn sie wird zu selten gestellt: Zitat (Goto Java 2): Zu jedem primitiven Datentyp in Java gibt es eine korrespondierende Wrapper-Klasse. Diese kapselt die primitive Variable in einer objektorientierten Hülle und stellt eine Reihe von Methoden zum Zugriff auf die Variable zur Verfügung. Zwar wird man bei der Programmierung meist die primitiven Typen verwenden, doch gibt es einige Situationen, in denen die Anwendung einer Wrapper-Klasse sinnvoll sein kann. Diese Klassen, wie zum Beispiel "Integer" koennen einem das Leben angenehmer gestalten, wenn man Dinge tun muss, die man mit einfachen ints tun will, aber mangels vorhandener Methoden nicht kann, weil diese Primitiven eben keine richtigen Objekte sind. Zum Beispiel kann Integer (im Gegensatz zu int) Strings nach Zahlen parsen, oder Integers als Binaercode ausgeben oder als Hex oder in andere Zahlentypen umwandeln und vieles mehr. Vielleicht ist es fuer Dich noch interessant zu erfahren, dass diese Wrapper Klassen in der Praxis oftmals nicht instantiiert, sondern ihre Methoden statisch aufgerufen werden. Um zum Beispiel aus dem String "42" das betreffende int zu machen, rufst Du: String zweiundvierzig = new String ("42") ; int answer = Integer.parseInt (zweiundvierzig) ; Das brauchst Du zum Beispiel zum Auswerten von GUI-Zahlenfeldern. Ich hoffe, ich konnte ein wenig Licht ins Dunkel bringen. Das Verstaendnis von Wrapperklassen und deren Sinn halte ich naemlich fuer essentiell, wenn man mit OOP beginnt. 3.1.22. Warum ist private nicht privat? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ public class Person { private int kontostand; public Person(int kontostand) { this.kontostand = kontostand; } public void addGehalt(int gehalt) { this.kontostand += gehalt; } public void klauen(Person opfer) { this.kontostand += opfer.kontostand; opfer.kontostand = 0; } public void zeigeKontostand() { System.out.println("Kontostand: " + this.kontostand); } } public class Test { public static void main(String[] args) { //Der Dieb eröffnet ein Konto Person dieb = new Person(10); //Das Opfer eröffnet ein Konto Person opfer = new Person(50000); //Das Opfer bekommt Gehalt opfer.addGehalt(10000); //Der Dieb geht an die Arbeit dieb.klauen(opfer); //Das opfer ist nun pleite!!! opfer.zeigeKontostand(); //Und der Dieb un 60000 Euro reicher. dieb.zeigeKontostand(); } } Wenn man obiges Programm testet, so wird man feststellen, daß es möglich ist, die private-Datenfelder eines Objektes zu manipulieren; diese Daten sind also nicht privat im sonst üblichen Sinne. Allerdings ist die Privatsphäre nur für Objekte der gleichen Klasse aufgehoben, Objekte anderer Klassen haben keinen Zugriff auf die private-Daten von Objekten anderer Klassen. Damit ist obige Möglichkeit nicht weiter tragisch, denn der Entwickler der Klasse kann eine wie oben gezeigte Möglichkeit wirksam unterbinden. Wenn er dies nicht tut, so ist die Schuld bei ihm zu suchen, denn nur der Entwickler allein ist für das Verhalten der Klassen zuständig und nur der Entwickler muß solche Möglichkeiten durch das Design ausschließen. Die private-Deklaration ist damit als Deklaration der Privatsphäre gegenüber Objekten anderer Klassen zu sehen, zwischen Objekten der gleichen Klasse herrscht ein freundschaftliches Verhältnis, sie dürfen sich gegenseitig in die Daten schauen. 3.2. [STRING] - Fragen die unmittelbar mit Strings zu tun haben. ---------------------------------------------------------------- 3.2.1. Wie vergleiche ich zwei Strings in Java? Autor: Markus Reitz, Martin Erren ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem: Man versucht zwei Strings in der Form if(stringEins == stringZwei) { System.out.println("stringEins und stringZwei sind gleich."); } zu vergleichen und erhält alles andere als ein richtiges Ergebnis. Der Grund ist der, daß mit dem "=="-Operator nur die beiden Referenzen miteinander verglichen werden, nicht jedoch die Objekte. Man erhält deshalb womöglich auch bei zwei gleichen Strings das Ergebnis, daß sie verschieden sind. Für den inhaltlichen Vergleich, nicht nur von Strings, sondern allgemein von Objekten, wird in Java die Methode equals(Object obj) verwendet, die nicht immer nur Referenzen, sondern je nach Klasse auch die Inhalte (sprich ihre Daten) vergleicht. Obige Abfrage müßte also if(stringEins.equals(stringZwei)) { System.out.println("stringEins und stringZwei sind gleich."); } lauten, damit das gemacht wird, was eigentlich gewünscht ist. Im Zusammenhang mit Strings ist noch eine Besonderheit zu erwähnen: if ("Java".equals(stringZwei)) { System.out.println("stringZwei ist gleich zu Java."); } ist zulässig, der Compiler erzeugt aus der Zeichenkette automatisch ein String-Objekt; man muß also nicht zuerst ein Objekt anlegen und den String Java dort speichern. 3.2.2. Wie wandle ich einen String in einen Integer? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Klassen können Methoden besitzen, die die Konvertierung eines Objekts dieser Klasse in ein Objekt einer anderen Klasse übernehmen. Zu dem elementaren Java-Datentyp int gibt es eine sogenannte Wrapper-Klasse Integer, die den elementaren Datentyp in einer Klasse kapselt .Diese Klasse stellt eine Methode (in diesem Fall eine Klassenmethode) zur Verfügung, die das Gewünschte leistet: public class Test { public static void main (String[] params) { String stringMitZahl = "50"; int zahl = 0; try { zahl = Integer.parseInt(stringMitZahl); } catch (NumberFormatException e) { e.printStackTrace(); } zahl = zahl + 10; System.out.println("Die Variable zahl = " + zahl); } } 3.2.3. Wie wandle ich einen Integer in einen String um? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Dieses Problem ist genau das Gegenteil des vorherigen. Wie die Klasse Integer, so besitzt auch die Klasse String eine Methode, die das Problem löst, allerdings heißt die Methode nicht parseString, was man analog schließen könnte, sondern valueOf. public class Test { public static void main (String[] params) { int zahl = 50; String stringMitZahl = String.valueOf(zahl); System.out.println("Die Variable stringMitZahl = " + stringMitZahl); } } 3.2.4. Wie wandle ich einen Integer in einen HexString um? Autor: Uwe Günther ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das Problem ist ähnlich wie das Konvertieren von einem Integer in einen String. Wie die Klasse String die Klassenmethode valueOf besitzt, um einen String zu erzeugen, so besitzt die Klasse Integer die Klassenmethode toHexString(int i). public class Test { public static void main (String[] params) { int zahl = 50; String stringAlsHex = Integer.toHexString(zahl); System.out.println("Die Variable stringAlsHex = " + stringAlsHex); } } Der Nachteil der Integer.toHexString(int i) Methode ist, dass sie alle führenden Nullen einer Hex-Repräsentation abschneidet. 3.2.5. Wie kann ich eine Zahl formatieren und wie lege ich die Anzahl der Nachkommastellen fest? Autor: Karsten Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das kann die Klasse java.text.NumberFormat und deren Abkömmlinge erledigen. Beispiel: import java.text.DecimalFormat; public class Zahl { public static void main(String[] args) { double betrag = 1000d/3d; // -> 333.333333... DecimalFormat df = new DecimalFormat("#.##"); System.out.println(df.format(betrag)); df = new DecimalFormat("#.## DM"); System.out.println(df.format(betrag)); df = new DecimalFormat("0000.0000"); System.out.println(df.format(betrag)); } } Die Ausgabe des Programms sind formatierte Dezimalzahlen: 333,33 333,33 DM 0333,3333 In der API-Dokumentation der Klassen java.text.Decimalformat und java.text.NumberFormat werden alle weiteren Formatierungsoptionen erläutert. Falls die Umwandlungen von double nach String zeitkritisch durchgeführt werden müssen, lohnt sich ein Blick auf <URL:http://www.onjava.com/pub/a/onjava/2000/12/15/formatting_doubles.html> Dort erklärt Jack Shirazi (Autor des Buches "Java Perfomance Tuning") andere Konvertierungsmethoden. 3.2.6. Wie kann ich ein Datum formatieren? Autor: Karsten Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das machen andere für Dich,... Benutze einfach die Klassen DateFormat aus dem package java.text. Folgendes Beispiel zeigt Dir die Anwendung der SimpleDateFormat-Klasse: import java.util.Date; import java.text.SimpleDateFormat; public class Datum { public static void main(String[] args) { SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd"); System.out.println(sd.format(new Date())); sd.applyPattern("dd.MM.yyyy"); System.out.println(sd.format(new Date())); } } Die Ausgabe des Programms sind formatierte Datümer: 2000-12-24 24.12.2000 In der API-Dokumentation zur Klasse java.text.SimpleDateFormat sind die Kürzel der verschiedenen Datumskomponenten für Tag, Monat, usw. aufgeführt. 3.2.7. Wie kann ich in einem String oder StringBuffer mehrere Zeichen suchen und ersetzen? Autor: Martin Erren ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Mit String String#replace(char,char) kann ich nur einzelne Zeichen suchen und mit StringBuffer replace(int,int,String) nur ersetzen aber nicht suchen. Lösung: Eine gute Hausaufgabe. Was man hier braucht, ist eine Kombination von int String#indexOf(String,int), String String#substring(int,int) mit einem neu aufzubauenden StringBuffer. bzw. int StringBuffer#indexOf(String,int) StringBuffer#replace(int,int,String) Die folgende Lösung ist eine unter vielen und ersetzt alle Vorkommen von "search" in "source" mit "replace": public static String replaceAll(String source, String search, String replace) { if(search.equals(replace)) { return source; //kann ja sein, dass wir nichts tun müssen } StringBuffer result = new StringBuffer(); int len = search.length(); if(len == 0) { return source; //verhindert Endlosschleife bei search.equals(""); } int pos = 0; //position int nPos; //next position do { nPos = source.indexOf(search, pos); if(nPos != -1) { //gefunden result.append(source.substring(pos, nPos)); result.append(replace); pos = nPos+len; } else { //nicht gefunden result.append(source.substring(pos)); //letzter abschnitt } } while(nPos!= -1); return result.toString(); } Da sowas praktisch überall gebraucht wird, gibt es unzählige Bibliothek(chen) im Netz, die so etwas anbieten, z.B. <URL:http://ostermiller.org/utils/StringHelper.java.html> BTW: Der Link muss as den 3 Zeilen zusammen gestzt werden! [...vielleicht noch mehr und geeignetere Adressen...] 3.2.8. Gibt es reguläre Ausdrücke in Java (regular expressions)? Autor: Karsten Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ja, natürlich. Bis zum J2SDK 1.4 muss man, um reguläre Ausdrücke in Java zu benutzen, auf externe packages zurückgreifen. Eines der ausgereiftesten ist das Regexp-Paket aus dem Jakarta-Projekt: http://jakarta.apache.org/regexp/index.html Ab dem J2SDK 1.4 wird es jedoch ein package java.util.regex geben, das somit die Möglichkeit zur Benutzung der regulären Ausdrücke direkt in die Klassenhierarchie einbaut. Nachfolgend ein Beispiel für die Nutzung dieses packages (Achtung: funktioniert nur ab J2SDK 1.4 aufwärts!). Das Beispielprogramm zeigt, wie in der Stringvariablen 'input' nach einem Muster (Pattern) gesucht wird, das auf einer Ziffer, mindestens einem Buchstaben und einer weiteren Ziffer besteht: import java.util.regex.Matcher; import java.util.regex.Pattern; public class PatternTest { public static void main(String[] args) { String input = "Test für Regex Ausdrücke 1xxx2 n444n."; Pattern p = Pattern.compile("\\d\\D+\\d"); // Muster: Ziffer, mind. ein Buchstabe, Ziffer Matcher m = p.matcher(input); if (m.find()) { System.out.println("Muster an Pos. " + m.start()); System.out.println("Muster ist: " + m.group()); } else { System.out.println("Muster nicht gefunden"); } } } Die Ausgabe dieses Programms ist: Muster an Pos. 25 Muster ist: 1xxx2 Weitere Infos in der API-Dokumentation zu java.util.regex. 3.3. [IO] - Frage bezüglich Eingabe/Ausgabe, Streams, etc. in Java. ------------------------------------------------------------------- 3.3.1. Verlangsamt Serialisierung mein Programm? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Java bietet mit dem Mechanismus der Serialisierung auf einfache Weise die Möglichkeit, den aktuellen Zustand des Objekts auf einem Datenträger, das Netz oder sonst wohin über einen Stream zu sichern. Der verwendete Mechanismus ist relativ kompliziert, damit auch alle auftretenden Möglichkeiten korrekt behandelt werden können. Sind die Daten der Objekte sehr groß, so empfiehlt es sich, eigene Prozeduren zur Speicherung zu entwickeln, die dann nicht mehr allgemeingültig, aber auf die aktuelle Verwendung angepaßt und damit schneller sind. 3.3.2. Wie kann ich rekursiv einen Verzeichnisbaum abarbeiten? Autor: Marco Schmidt ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In java.io.File befinden sich die dazu benötigte Funktionalität. Mit list() läßt man sich ein Array mit allen Dateinamen geben, mit isDirectory() läßt sich prüfen, ob es sich bei dem File-Objekt um ein Verzeichnis handelt. Indem man nun rekursiv in Unterverzeichnisse absteigt, kann man so einen kompletten Verzeichnisbaum abarbeiten. Hier ein Beispielprogramm (scantree.java): import java.io.File; public class scantree { public static void main(String[] args) { // Programm muss einen Verzeichnisnamen als Parameter haben File dir = new File(args[0]); scan(dir); } public static void scan(File dir) { // Liste aller Dateien und Unterverzeichnisse holen String[] entries = dir.list(); if (entries == null || entries.length < 1) { return; } for (int i = 0; i < entries.length; i++) { File entry = new File(dir, entries[i]); if (entry.isDirectory()) { scan(entry); // rekursiv ins Unterverzeichnis verzweigen } else { // entry ist eine Datei System.out.println(entry); } } } } 3.3.3. Wie kann ich aus Dateien zeilenweise lesen? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Generell nutzt man für die Datei-Operationen einen Buffered Reader oder eine Klasse, die von dieser abstammt. Diese Klasse besitzt dann die Methode readLine(), die eine Zeile aus der Datei ausliest und diese Zeile als einen String zurückgibt. Zu beachten ist, daß bei Erreichen des Dateiendes kein leerer String, sondern eine Nullreferenz zurückgegeben wird. Ein Programm, daß aus einer Datei zeilenweise liest, sieht in Java wie folgt aus: import java.io.*; public class ZeilenWeiseLesen { public static void main(String[] args) { try { String zeile; //Wir lesen aus "eingabe.txt". File eingabeDatei = new File("eingabe.txt"); FileReader eingabeStrom = new FileReader(eingabeDatei); BufferedReader eingabe = new BufferedReader(eingabeStrom); while ((zeile = eingabe.readLine()) != null) { System.out.println(zeile); } } catch (IOException e) { e.printStackTrace(); } } } 3.3.4. Wie kann ich Exponentialzahlen (z.B. 1.09E+008) aus einer Datei lesen? Autor: Wolfram Rühaak ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Mit Java führt folgendes Verfahren zum Ziel: Lies die Daten als Strings ein und wandel sie mittels Double.valueOf(my_string).doubleValue() in einen double Wert um. Das StreamTokenizer keine Exponentialzahlen kennt hat von Sun Bug Status bekommen (obgleich der StreamTokenizer so arbeitet wie angegeben): * BugId: #4079180 Synopsis: java.io.StreamTokenizer: Add ability to read full Java floating-point syntax Der Sun Workaround soll wohl ein: public void parseExponentialNumbers(boolean flag) sein. Beispiel: import java.io.*; import java.util.Vector; /** * @author Wolfram Rühaak * Beispielcode, der zeigt wie man Zahlen aus einer Datei liest. * Die Datei darf in diesem Fall nur Zahlen enthalten, getrennt durch * Tabulator oder Space. * Die Anzahl von Spalten/Zeilen ist nicht vorgegeben. * Um *.cvs Kompatibilät zu erhalten kann man als whitespaceChars * noch ',' und ';' hinzufügen. */ public class ReadExponential { int ni; // Anzahl Zeilen int nj; // Anzahl Spalten private ReadExponential(String Filename) { int i=0; int j=0; Vector v2 = new Vector(); try { FileInputStream fis = new FileInputStream(Filename); BufferedReader r = new BufferedReader(new InputStreamReader(fis)); StreamTokenizer st = new StreamTokenizer(r); /* * Nachfolgendes Code-Fragment von: * Mark Gritter (mgritter@pup16.stanford.edu) * Betrifft:Re: This is easy in C++ (asking for help) * Newsgroups:comp.lang.java.programmer * Datum:1997/11/07 */ st.resetSyntax(); st.whitespaceChars(' ', ' '); st.whitespaceChars('\n', '\n'); st.wordChars('0','9'); st.wordChars('e','e'); st.wordChars('E','E'); st.wordChars('.','.'); st.wordChars('+','+'); st.wordChars('-','-'); /* Ende Code-Fragment */ st.eolIsSignificant(true); try { while(st.nextToken() != st.TT_EOF) { String s1 = st.sval; if(s1!=null) { // Wert in Vector schreiben v2.addElement(s1); // Anzahl von Zeilen i=st.lineno(); } } } catch(IOException ioe) {} } catch (FileNotFoundException fnfe) {} ni = i - 1; nj = ((v2.size())/(ni+1))-1; // Anzahl von Spalten berechnen double[][] dAllValues = new double [ni+1][nj+1]; int k=0; for(i = 0;i <= ni; i++) { for(j = 0;j <= nj; j++) { Object f = v2.elementAt(k); // Vector in String s = f.toString(); // Array umspeichern /* * Double.valueOf(String s) kann jeden numerischen Wert * von String nach double umwandeln */ dAllValues[i][j] = Double.valueOf(s).doubleValue(); k++; } } } } 3.3.5. Wie kann ich mit Java Dateien kopieren? Autor: Martin Erren, Uwe Günther, Ulf Jährig, Christian Kaufhold ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Bestimmt die performanteste Lösung wäre, mit System.exec(...) die Aufgabe dem Betriebssystem zu übergeben. Der Nachteil ist hier, dass so schwer ein plattformunabhängiger Code erreichbar ist und die Fehlerbehandlung schwierig wird. Deshalb einfach eine Datei lesen und in eine andere, neue Datei schreiben, z.B. so: import java.io.*; public static void copyFile(File src, File dest, int bufSize, boolean force) throws IOException { if(dest.exists()) { if(force) { dest.delete(); } else { throw new IOException( "Cannot overwrite existing file: " + destName); } } byte[] buffer = new byte[bufSize]; int read = 0; InputStream in = null; OutputStream out = null; try { in = new FileInputStream(src); out = new FileOutputStream(dest); while(true) { read = in.read(buffer); if (read == -1) { //-1 bedeutet EOF break; } out.write(buffer, 0, read); } } finally { // Sicherstellen, dass die Streams auch // bei einem throw geschlossen werden. // Falls in null ist, ist out auch null! if (in != null) { //Falls tatsächlich in.close() und out.close() //Exceptions werfen, die jenige von 'out' geworfen wird. try { in.close(); } finally { if (out != null) { out.close(); } } } } } Das schwierigste ist hier wohl die Fehlerbehandlung, die je nach Anforderung unterschiedlich sein kann. Anmerkung: Ein paar exotische VMs optimieren read(byte[]) bzw. write(byte[]) nicht, so dass hier ein BufferedInputStream oder BufferedOutputStream evtl. angebracht ist. 3.3.6. Warum kann ich meine Bilder nicht mehr laden, nachdem ich sie in ein Jar gesteckt habe? Autor: Martin Erren, Paul Ebermann ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Auf Ressourcen in einer Jar-Datei kann man nicht mit File und FileInputStream zugreifen. Stattdessen gibt es einen allgemeineren Mechanismus, der Daten von dort holt, wo auch die Klassen hergeholt werden: URL Class#getResource(String) und InputStream Class#getResourceAsStream(String) sind Deine Freunde. Laut API-doc ist "/img.jpg" relativ zur codeBase, also dem aktuellen Eintrag im CLASSPATH, wo Deine Klasse geladen wurde, und "img.jpg" relativ zur Klasse, also im selben Verzeichnis, wo auch die Klasse liegt. Ob Applikation oder Applet, *.jar oder file-system spielt hier keine Rolle. mit System.out.println(MyClass.class.getResource("/").toString()); kannst Du jederzeit feststellen, welche codebase die jeweilige Klasse hat. Weiterhin sind InputStream ClassLoader.getSystemResourceAsStream(name); und URL ClassLoader.getSystemResource(name) für eigene Ressourcen nicht zu empfehlen, da man nicht immer seine eigene Klasse vom SystemClassLoader lädt (und nur dann wären die Ressourcen an der gesuchten Stelle). 3.4. [NET] - Frage bezüglich Netzwerk. -------------------------------------- 3.4.1. Wie kann ich einen Ping in Java realisieren? Autor: Stephan Menzel ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Eigentlich gar nicht. Ein Ping (ICMP) ist eine hardwarenahe Angelegenheit, die im Gegensatz zu dem hardwarefernen abstrahierenden Konzept von Java steht. Die Antworten einer Netzwerkkarte sind da nicht so sehr relevant, wie ein im Netzwerk vorhandener Dienst. So kann zum Beispiel ein Rechner auf Pings nicht antworten und trotzdem einen Dienst anbieten. Oder die Pings verenden an einer Firewall oder aber der Rechner auf dem das Programm laeuft, ist gar nicht in der Lage, zu pingen. Das bedeutet, es ist sicherer und besser, einfach eine Testweise Socketverbindung zu der betreffenden Zieladresse aufzubauen und eine evtl. auftretende Exception als Zeichen fuer dessen Abwesenheit im Netz zu deuten. Folgendes Beispiel soll dies zeigen: import java.io.*; import java.net.*; .. static Socket nntpsock; // Der Socket fuer die Newsverbindung static BufferedReader in; static OutputStreamWriter out; ... try { nntpsock = new Socket("news.cis.dfn.de", 119); // Verbinden nntpsock.setSoTimeout(300); // Timeout auf 300ms in = new BufferedReader( new InputStreamReader(nntpsock.getInputStream())); out = new OutputStreamWriter(nntpsock.getOutputStream()); } catch (UnknownHostException e) { System.err.println("Unknown Host.:" + e.toString()); } catch (IOException e) { System.err.println("Rechner nicht erreichbar. :" + e.toString()); } ... 3.5. [AWT] - Frage bezüglich AWT. --------------------------------- 3.5.1 Wenn ich einen Listener bei mehreren Buttons anmelde, wie kann ich dann unterscheiden, welcher gedrückt wurde? Autor: Michael Paap, Christian Kaufhold, Georg Lippitsch ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Wenn Du so vorgehst wird, egal welcher Button geclickt wird, die Methode actionPerformed(ActionEvent ev) des Listeners aufgerufen. Mit ev.getSource() bekommst Du nun eine Referenz auf die Ereignisquelle (als Object). Dann kannst Du schauen, welcher Button geclickt wurde, z.B. indem Du diese Ereignisquelle mit den vorhandenen Buttons vergleichst oder indem Du auf Button castest und ihre Beschriftung ausliest. Beispiel: Angenommen, Du hast einen ActionListener bei jedem Button eines Arrays von 4 Buttons registriert. Dann könnte die Methode actionPerformed im Listener wie folgt aussehen: public void actionPerformed(ActionEvent ev) { int pressed = -1; for (int i=0; i<myButtons.length; i++) { if (myButtons[i] == ev.getSource()) { pressed = i; break; } } // hier abhängig von pressed verschiedene Aktionen // ausführen } oder so: public void actionPerformed(ActionEvent ev) { Button pressed = (Button) ev.getSource(); System.out.println("Pressed: " + pressed.getLabel()); } Eine weitere Möglichkeit bietet die Methode Button#setActionCommand(String command) Hiermit kann ein dem Knopf ein beliebiger String zugewiesen. Dieser kann mit ActionEvent#getActionCommand() wieder abgefragt werden. Dabei wird immer der String zurückgegeben, der dem Event auslösenden Knopf zugewiesen wurde. Ein Beispiel: Button knopf1 = new Button("Max"); knopf1.setActionKommand("schlimmer bub 1"); Button knopf2 = new Button("Moritz"); knopf2.setActionKommand("schlimmer bub 2"); public void actionPerformed(ActionEvent ev) { String c = ev.getActionCommand(); if (c.equals("schlimmer bub 2")) System.out.println("Moritz wurde aktiviert"); } 3.5.2. Kann ich ein Fenster (Frame/JFrame) maximieren? Autor: Karsten Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Antwort: Jein. Bis zum J2SDK 1.3 (einschließlich) gibt es keine Möglichkeit, ein Fenster zu maximieren. Es gibt nur verschiedene Workarounds, um ein Fenster möglichst flächendeckend auf dem Desktop darzustellen (s.u.) Ab dem J2SDK1.4 gibt es die Methode setExtendedState(int state) aus der Klasse java.awt.Frame, mit der das Fenster *vielleicht* maximiert wird. Ob das möglich ist, kann mittels isFrameStateSupported(int state) aus dem Toolkit ermittelt werden, denn nicht jede Plattform unterstützt solche maximierten Fenster. Für Anwendungen, die mittels einer J2SDK-Version bis 1.3 erstellt werden sollen, gibt es nur Workarounds, da es eine "Maximieren"-Funktion nicht gibt. Für den Windows-Benutzer mag das merkwürdig sein, für den Unix-Benutzer ist der Gedanke merkwürdig, dass die tatsächliche Bildschirmgrösse etwas mit der Desktopgröße zu tun haben sollte. Lange Rede, kurzer Code: um ein Fenster möglichst groß zu machen, nehme man setSize(getToolkit().getScreenSize()); Hierdurch wird das darzustellende Fenster vielleicht auf die Größe der aktuellen Bildschirmauflösung gesetzt. Ohne Berücksichtigung evtl. darzustellender Menü- und/oder Taskleisten. Falls auf der Laufzeitplattform ein öffnendes Programmfenster von einem Fenstermanager platziert wird, hat die setSize(Dimension)-Methode möglicherweise keine Auswirkung auf das Fenster. Der Programmierer sollte sich also nicht darauf verlassen, dass sein Fenster so dargestellt wird, wie er es programmiert hat! Eine weitere Möglichkeit, ein Fenster evtl. zu maximieren besteht darin, die Klasse java.awt.Robot (seit J2SDK 1.3) zu benutzen, um die Maximieren-Schaltfläche programmgesteuert anklicken zu lassen. Hinweise zur Benutzung dieser Klasse finden sich im JDC Tech Tip vom 11. Juli 2000 <URL:http://developer.java.sun.com/developer/TechTips/2000/tt0711.html) Wegen dieser ganzen Unwägbarkeiten ist es oft eine Alternative, statt das Fenster zu maximieren, es einfach Wiederherzustellen und die Größe und Position des Fensters von einem vorherigen Programmlauf zu benutzen. Hierbei sollte jedoch darauf geachtet werden, dass die Geometrie eines maximierten Fensters *nicht* durch ein normales Fenster nachgebildet wird, weil der Anwender sonst dadurch verwirrt wird, dass das Fenster maximiert aussieht, es aber in Wirklichkeit nicht ist! 3.5.3. Wie tausche ich die Kaffeetasse im blauen Balken aus? Autor: Karsten Schulz, Roger Schuster, Christian Wederhake ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit java.awt.Frame#setIconImage(java.awt.Image). Beispiel: ImageIcon icon = new ImageIcon("meinBildchen.gif"); setIconImage(icon.getImage()); 3.6. [SWING] - Frage bezüglich Swing. ------------------------------------- 3.6.1. Wie mache ich globale Font-Änderung für meine Komponenten? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * UIManager.put("component.font", new FontUIResource(...)); 3.6.2. Wie kann ich bei der Eingabe in ein JTextField die Anzahl der eingebbaren Zeichen beschränken? Autor: Alexander Elsholz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Wenn ein JTextField benutzt wird sollte man ein benutzerdefiniertes Document implementieren. Für AWT-Textfelder funktioniert es mit einigen Anpassungen auch über das Interface KeyListener. import javax.swing.text.PlainDocument; import javax.swing.text.BadLocationException; import javax.swing.text.AttributeSet; /** * Diese Klasse ist ein Dokument für Textfelder, welches die Eingabe auf * x Zeichen begrenzt. * * Die Zuweisung geschieht über * JTextfield.setDocument(new Validation(int anzahl)); */ public class Validation extends PlainDocument{ private int limit; /** * Konstruktor für das Validationdokument * @param int limit: maximale Anzahl der einzugebenen Zeichen */ public Validation(int newLimit){ super(); if (limit < 0){ limit = 0; } else { limit = newLimit; } } /** * Funktion überschreibt die Methode insertString von PlainDocument * @param int offset: Position * @param String str: der String * @param AttributeSet attr: Attributset */ public void insertString (int offset, String str, AttributeSet attr) throws BadLocationException { if (str == null) return; if ((getLength() + str.length()) <= limit){ super.insertString(offset, str, attr); } } } Die hier aufgezeigte Lösung zur Begrenzung von Textfeldern kann auch verwendet werden, wenn unerwünschte Zeichen in einem Textfeld nicht eingegeben werden dürfen. 3.6.3. Wie setze ich den Cursor an den Anfang der JTextArea? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * textarea.setCaretPosition(0); 3.6.4. Wie scrolle ich an das Ende der JTextArea? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Hierzu existieren mehrere Möglichkeiten: * textarea.setCaretPosition(textarea.getDocument().getLength()); * try{ textarea.scrollRectToVisible(textarea.modelToView( textarea.getDocument().getLength())); } catch (BadLocationException be) { be.toString(); } * (Geht auch, weniger schön): mit getText().length(); Scrolling wrappen in SwingUtilities.invokeLater(), bspw: SwingUtilities.invokeLater(new Runnable() { public void run() { // scrolling code } }; 3.6.5. Wie bekomme ich es hin, das der Benutzer in meiner JTable keine Eingaben tätigen kann? Autor: Alexander Elsholz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das funktioniert über das Tabellenmodell deiner JTable: import javax.swing.table.DefaultTableModel /** * Diese Klasse repräsentiert das Datenmodell für eine oder mehrere * Tabellen * * Die Zuweisung geschieht über JTable.setModel(new YourTableModel())); */ public class YourTableModel extends DefaultTableModel { /** * aus der API: Returns true if the cell at rowIndex and columnIndex * is editable. Otherwise, setValueAt on the cell will not change the * value of that cell. */ public boolean isCellEditable(int row, int column) { return false; } } Dieses Bespiel verhindert das Editieren von zellen in allen Zellen der Tabelle, durch Auswerten der Parameter könn aber auch einzelne Spalte, Zeilen oder Zellen gesperrt werden. 3.6.6. Wie bekomme ich eine horizontale ScrollBar bei JTable? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF); 3.6.7. Wie scrolle ich ans Ende von JTable? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * table.scrollRectToVisible(table.getCellRect( table.getRowCount()-1,-1,true)); 3.6.8. Wie verhindere ich ein reordering der Spalten bei JTable? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * table.getTableHeader().setReorderingAllowed(false); 3.6.9. Wie verhindere ich ein Resizen der Spalten bei JTable? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * table.getTableHeader().setResizingAllowed(false); 3.6.10. Wie ändere ich die Hintergrundfarbe von JScrollPane? Autor: Linda Radecke ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das geht mit: * scrollpane.getViewport().setBackground(new Color(....)); 3.6.11. Wie kann ich ein JLabel dazu bringen, seinen Hintergrund zu füllen? Autor: Gerhard Bloch ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ JLabel zeichnet (wie die meisten Swing-Komponenten) seinen Hintergrund nicht, wenn es nicht "opaque" ist (obwohl dies unterschiedliche Dinge sind). Loesung: Fuer *undurchsichtige* Hintergrundfarben funktioniert folgendes: JLabel l = new JLabel("Text"); l.setOpaque(true); l.setBackground(Color.red); Diese Loesung funktioniert auch fuer transparente Hintergrundfarben: public class JLabelWithBackground extends JLabel { public JLabelWithBackground(String title) { super(title); } public void paintComponent(Graphics g) { if (!isOpaque()) { Rectangle vr = getVisibleRect(); g.setColor(getBackground()); g.fillRect(vr.x, vr.y, vr.width, vr.height); } super.paintComponent(g); } } JLabel l = new JLabelWithBackground("Text"); l.setBackground(new Color(255, 0, 0, 128)); 3.6.12. Warum reagiert meine GUI nicht, während eine längere Berechnung ausgeführt wird? Autor: Tobias Vogele ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Im Prinzip funktioniert das folgendermaßen: Es gibt bei Swing einen besonderen Thread: den Event Dispatch Thread (EDT). Wenn immer Du ein Event von Deiner GUI bekommst, z.B. ein ActionEvent, dann befindest Du Dich im Event Dispatch Thread (EDT). In diesem werden aber nicht nur Events, die der Benutzer z.B. durch Mausklicks verursacht hat, erzeugt, sondern in diesem Thread wird auch die Anforderung für das Neuzeichnen verarbeitet Das Problem ist nun: Wenn Du im EDT (z.B. bei der Behandlung eines GUI-Events) eine längere Berechnung oder was auch immer ausführst, dann kann in diesem Thread natürlich so lange nichts anderes passieren, also kann sich auch die GUI auch nicht mehr neu zeichnen, obwohl es vielleicht nötig wäre. Das bedeutet auch, daß Änderungen, die während der Berechnung an der GUI vorgenommen werden, nicht sichtbar sind, bevor die Berechnung nicht beendet ist, da erst dann die GUI neu gezeichnet werden kann. Die Lösung ist daher: Du mußt Deine Berechnung in einem anderen Thread ausführen. Das weitere Problem dabei: Wenn diese Berechnung Änderungen an der GUI veranlaßt, dann müssen diese wieder im EDT ausgeführt werden, da Swing im allgemeinen nicht thread-safe ist. Wie geht beides: Einen neuen Thread starten: new Thread(calculation, "CalculationThread").start(); Etwas im EDT ausführen: SwingUtilites.invokeLater(guiChanges); Weitere Informationen dazu und alternative Lösungsansätze: 1) Artikel-Serie "Threads and Swing" http://java.sun.com/products/jfc/tsc/articles/threads/threads1.html 2) Foxtrott, ein Rahmenwerk um anders zu schreiben, was der Swing-Worker aus 1) kann: http://foxtrot.sourceforge.net/ 3) Spin, eine weitere Threading-Bibliothek für Swing http://spin.sourceforge.net/ Hier ein konkretes, lauffähiges Beispiel: Während einer längeren Berechnung soll eine ProgressBar den Fortschritt anzeigen. import java.awt.FlowLayout; import java.awt.event.*; import javax.swing.*; public class Beispiel implements ActionListener{ JProgressBar progressBar = new JProgressBar(0, 10); public void actionPerformed(ActionEvent e) { Runnable calculation = new Runnable() { public void run() { bigCalculation(); } }; // Neuen Thread starten: new Thread(calculation, "CalculationThread").start(); } /** * Hier ist die große Berechnung, die gleichzeitig die * ProgressBar updaten soll. */ private void bigCalculation() { for (int i = 0; i <= 10; i++) { calculateNextStep(); setProgress(i); } } void calculateNextStep() { try { Thread.sleep(500); } catch (InterruptedException e) { } } void setProgress(final int newProgress) { // Wert der ProgressBar im EDT ändern: SwingUtilities.invokeLater(new Runnable() { public void run() { progressBar.setValue(newProgress); } }); } public static void main(String[] args) { Beispiel bsp = new Beispiel(); JButton button = new JButton("Rechne..."); button.addActionListener(bsp); JFrame frame = new JFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.getContentPane().setLayout(new FlowLayout()); frame.getContentPane().add(button); frame.getContentPane().add(bsp.progressBar); frame.pack(); frame.setVisible(true); } } Es sei hier auch noch auf das Tutorial von Sun zur Verwendung von JProgessBars hingewiesen, da dort anders vorgegangen wird als hier: http://java.sun.com/docs/books/tutorial/uiswing/components/progress.html Dort wird die JProgressBar über einen Timer angesteuert und nicht über einen expliziten Aufruf von setProgress. Allerdings war es ja hier gerade die Absicht, zu zeigen, wie man aus einem extra Thread heraus GUI-Methoden aufruft. 3.7. [APPLET] - Frage zu Java-Applets und ihre Zusammenarbeit mit Browsern. -------------------------------------------------------------- 3.7.1. Welche JDK-Version sollte ich für Applets verwenden, die möglichst allgemein lauffähig sein sollen? Autor: Stefan Menzel ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Am besten nicht über 1.1.8. 3.7.2. Wie bekomme ich den Internet Explorer dazu, das Plugin anstelle der integrierten JVM zu benutzen. Autor: Stefan Menzel, Aljoscha Rittner, Joachim Sauer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Indem auf der aufrufenden Webseite nicht das <APPLET>, sondern das <OBJECT>-Tag verwendet wird. Es gibt auf <URL:http://java.sun.com/products/plugin/1.3/docs/html_converter.html> einen automatischen Konverter einer Seite zur Benutzung des Plugins. Mit 1.4 kann auch das APPLET-Tag zusammen mit dem Plugin verwendet werden. Dazu findet man nähere Informationenen unter: <URL:http://java.sun.com/j2se/1.4/docs/guide/plugin/developer_guide/ html_converter_more.html> Anmerkung: Mit 1.4 kann auch das APPLET-Tag zusammen mit dem Plugin verwendet werden. Aber alle, die für JDKs größer 1.2 coden sollten ohnehin OBJECT verwenden, da sie mit APPLET (auch mit den neuen Plugins) auf Browser stoßen können, die zwar glauben es darstellen zu können, dann aber kläglich scheitern. Wer für 1.1 programmiert sollte sich wohl wirklich noch das APPLET-Tag überlegen. 3.7.3. Was dürfen unsignierte Applets nicht aus Sicherheitsgründen? Autor: Martin Erren ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Applets wurden generell stark in ihren Rechten eingeschränkt. Die genauen Einschränkungen sind von der Virtuellen Maschine, also Browser / Plugin oder Appletviewer abhängig. Einem signierten Applet kann man explizit mehr Rechte geben als das normalerweise der Fall ist. Auch gibt es Unterschiede, ob das Applet von remote oder vom Filesystem geladen wurde. Ein von remote geladenes Applet darf in der Regel nicht: * auf das lokale Filesystem zugreifen * auf die (System-)Zwischenablage zugreifen * Socketverbindungen zum lokalen Host aufbauen. * Socketverbindungen zu dritt-Hosts aufbauen. * System-properties ändern/setzen * System-properties lesen ausser: java.version, java.vendor,java.vendor.url, java.class.version os.name, os.arch, os.version, file.separator, path.separator, line.separator * lokal Programme starten * lokale Bibliotheken laden * System.exit(int) aufrufen * Fenster ohne Warnung öffnen Signieren heisst, das Applet mit einer verschlüsselten Unterschrift (Signatur) zu versehen, um diesen mehr Rechte zuzuweisen. Signieren bedarf einer "vertrauenswürdigen" Person bzw. Institution, unterschiedlich, je ob das Applet nur in einem Intra- oder im gesamten Internet betrieben werden soll. Der Prozess des Signieren-Lassens wurde leider noch zusätzlich dadurch erschwert, dass man jede Signatur praktisch für jede Browser-VM extra durchführen mus. Genaueres siehe: <URL:http://java.sun.com/sfaq> (Dort auch böse Testapplets.) Zur Java-Security und Codesignierung allgemein siehe: <URL:http://www.securingjava.com/toc.html> <URL:http://home.iSTAR.ca/~neutron/java.html> und spezieller: <URL:http://www.abim.net/jsw/index.htm> <URL:http://www.iw.uni-hannover.de/~ruemper/> <URL:http://www.suitable.com/Doc_CodeSigning.shtml> <URL:http://developer.netscape.com/docs/manuals/signedobj/signtool/ index.htm> (umgebrochen) <URL:http://java.sun.com/products/plugin/1.2/docs/nsobjsigning.html> <URL:http://developer.java.sun.com/developer/onlineTraining/ Programming/JDCBook/signed.html> (umgebrochen) 3.8. [SERVER] - Frage zu Servlets und anderen Server- Implementierungen in Java. ----------------------------------------------------- 3.9. [NONCORE] - Fragen zu Klassen/Packages, die über den Kern der Sprache hinausgehen, also Java3D etc. ------------------------------------------------------------------ 3.10. [OOP] - Frage bezüglich OOP-Konzepten und Patterns in Java. ---------------------------------------------------------------- 3.10.1. Was bedeutet Vererbung im OO-Kontext? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Vererbung ist in Java, und natürlich auch in anderen Programmiersprachen, nur eine Möglichkeit, um das konkrete Problem in den Computer zu übertragen. Das Prinzip der Vererbung ist dann anwendbar, wenn zwei Objekte in einer ist-ein oder ist eine Art von Beziehung zueinander stehen. Eine abgeleitete Klasse ist ein Subtyp der zugehörigen Oberklasse, besitzt also deren Eigenschaften (Daten & Methoden) und erweitert diese bei Bedarf um neue. LKW und PKW sind zum Beispiel Subtypen der Oberklasse Automobil, wobei beim LKW zum Beispiel die maximal zulässige Anhängerlast oder die Achsenanzahl hinzukommt. Wendet man das Prinzip der Vererbung an, so gilt das sogenannte Liskov'sche Substitutionsprinzip: Objekte der abgeleiteten Klasse können stets an die Stelle von Objekten der Oberklasse treten. 3.10.2. Was bedeutet Aggregation im OO-Kontext? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das Prinzip der Aggregation besagt, daß ein Objekt aus mehreren Teilen (=Objekten) besteht, die wiederrum aus Teilen bestehen können usw. Die Klasse Computer könnte z.B. aus den Klassen Speicher, Festplatte etc. bestehen. In einem Pseudo-Java-Code etwa so formuliert: public class Computer { private Speicher rom; private Speicher ram; private Speicher festPlatte; (...) } 3.10.3. Was bedeutet Assoziation im OO-Kontext? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Mit der Assoziation wird die Verbindung des Objektes zu einem oder mehreren anderen Objekten beschrieben. Assoziationen können kurzfristig sein, zum Beispiel dann, wenn ein anderes Objekt an das aktuelle Objekt als Parameter der Objektmethode übergeben wird. Sie können aber auch langfristig sein, wenn das Objekt Referenzen auf die assoziierten Objekte speichert (Registrierung). 3.10.4. Was bedeutet Benutzung im OO-Kontext? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das aktuelle Objekt benutzt eines oder mehrere andere Objekte um die anstehende Aufgabe erfüllen zu können. Das Objekt Backofen benutzt zum Beispiel das Objekt Thermostat, um die Aufgabe backen zu erfüllen, damit der Inhalt des Backofens nicht verkohlt. Es muß angemerkt werden, daß man häufig aus dem Programmcode keine direkte Entscheidung treffen kann, ob Aggregation, Assoziation oder Benutzung vorliegt. Diese drei Beziehungen sind prinzipiell Designprinzipien, die in der späteren Implementierungsphase, zum Beispiel in Java, in relativ ähnliche oder sogar identische Konstrukte umgesetzt werden. Es ist deshalb wichtig, daß man das jeweils zugrunde gelegte Prinzip dokumentiert, damit die Funktionsweise besser und einfacher nachvollzogen werden kann. 3.10.5. Worin liegen die Unterschiede zwischen abstrakten Klassen und Interfaces? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Java fügt dem schon von C++ her bekannten Konzept der abstrakten Klasse noch ein weiteres, aus der Sprache Objective-C entliehenes Feature hinzu: Interfaces. Ein Interface ist zuersteinmal nichts anderes als eine Auflistung von Methoden. Eine Klasse implementiert ein Interface, wenn sie alle in der Interface-Deklaration angegebenen Methoden besitzt. Wird mindestens eine der Methoden des Interfaces nicht implementiert, so wird die Klasse zu einer abstrakten Klasse. Mit dem Interface-Prinzip lassen sich in Java einfach Benutzt-Beziehungen modellieren. Eine Klasse benutzt eine andere Klasse in dem Sinn, daß es ganz spezielle Methoden dieser Klasse verwendet, um seine eigene Funktionalität zu realisieren - auf Daten der Hilfsklasse wird ja wegen dem Prinzip der Datenkapselung nicht direkt zugegriffen. Um ein Objekt zu benutzen, ist es nur wichtig, daß dieses Objekt die gewünschten Funktionen auch besitzt. Man definiert sich daher ein Interface, welches die benötigten Funktionen auflistet. Alle Objekte, die diese Funktionen benötigen, sprich, die dieses Interface verlangen, können nun all die Klassen verwenden, die dieses Interface implementieren. Im Sinne eines guten Klassendesigns ist es daher wichtig, solche Benutzt-Beziehungen zu lokalisieren, um die Klassen flexibler zu machen und unnötigerweise angewendete Vererbung zu eliminieren. Abstrakte Klassen sind im Gegensatz dazu Modellierungen des Ist ein-Prinzips und unterscheiden sich in dieser Hinsicht von Interfaces. 3.10.6. Was ist eine anonyme innere Klasse? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Eine anonyme innere Klasse trägt keinen Namen und wird vor allem bei der GUI-Programmierung für Adapterklassen verwendet. Wird eine solche Klasse in ein Class-File übersetzt, so werden alle anonymen Klassen, die in der umgebenden Klasse definiert wurden, von Null beginnend durhnummeriert. Testklasse$0.class ist also das Class-File der ersten in der Klasse Testklasse auftauchenden anonymen inneren Klasse. 3.10.7. Was ist ein immutable Objekt? Autor: Gerhard Bloch ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ein immutable (unveraenderliches) Objekt ist ein Objekt, das nach seiner Instanzierung nicht mehr veraendert werden kann. Bekannte Beispiele hierfuer sind saemtliche Wrapper-Klassen (Integer, Boolean,... ) sowie die Klasse String. Dieses Design-Pattern bietet folgende Vorteile: + Instanzen koennen gefahrlos mehrfach referenziert werden + keine Synchronisation noetig + sehr gut geeignet als Schluessel fuer HashMap Immutable Objekte muessen folgende Forderungen erfuellen: + alle Attribute sind final + alle nicht selbst immutable Attribute sind zusaetzlich private + kein Schreibzugriff auf Attribute moeglich + direkter Lesezugriff ist nur auf selbst immutable Attribute erlaubt + im Konstruktor uebergebene mutable Objekte muessen geklont(*) werden (*) Klonen ist hier in der Bedeutung "tief genug kopieren" gemeint: Es muessen rekursiv alle mutable Attribute kopiert werden. Dies hoert sich komplizierter an, als es in der Praxis ist, da die verwendeten Objekte i.d.R. nicht verschachtelt sind, reicht meist eine flache Kopie aus. Beispiel: public class MyImmutable { public final int i; private final String s; private final int[] a; private final Point p; public MyImmutable(int i, String s, int[] a, Point p) { this.i = i; // primitiver Typ ist immutable this.s = s; // String ist immutable this.a = new int[a.length]; // Arrays sind mutable! System.arraycopy(a, 0, this.a, 0, a.length); this.p = new Point(p); // Point ist mutable! } public String getS() { return s; } // Array ist mutable, also Klon zurueckgeben public int[] getA() { return (int[]) a.clone(); } // alternativ: Elementzugriff, die int-Elemente sind immutable public int getAAt(int pos) { return a[pos]; } // Point ist mutable, also Klon zurueckgeben public Point getP() { return new Point(p); } } Zusaetzlich ist folgendes zu beachten: Subklassen von Immutables muessen selbst nicht immutable sein und koennen im schlimmsten Fall sogar das Konzept unterlaufen! Beispiel: public class AntiImmutable extends MyImmutable { public String s; public AntiImmutable(int i, String s, int[] a, Point p) { super(i, "", a, p); this.s = s; } public String getS() { return s; } } MyImmutable mi = new AntiImmutable(0, "A", anIntArray, new Point(0, 0)); ((AntiImmutable)mi).s = "B"; System.out.println(mi.getS()); --> Ergibt "B"!!! Daher ist es meist angebracht, Immutables final zu deklarieren! Zudem sollte man Attribute, die zwar immutable, aber nicht final sind, wie Mutables behandeln (also im Konstruktor bzw. bei der Rueckgabe klonen). 3.11. [JDK] - Frage zu virtuelle Maschinen, alles über JDKs und deren Installation und Verwendung. --------------------------------------------------------------------- 3.11.1. Was ist ein Java Development Kit (JDK) Autor: Hubert Partl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das JDK ist eine Software, die für die Erstellung, Übersetzung und Ausführung von Java-Programmen notwendig ist; enthält unter anderem den Java-Compiler, das Java Runtime Environment JRE und diverse Hilfsprogramme. Der Name bedeutet übersetzt Java-Entwicklungs-Werkzeug. 3.11.2. Was ist ein Java Runtime Environment (JRE) Autor: Hubert Partl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das JRE ist eine Software, die für die Ausführung von Java-Programmen notwendig ist; enthält unter anderem die Java Virtual Machine JVM und die Klassenbibliothek. Der Name bedeutet übersetzt Java-Laufzeit- Umgebung. 3.11.3. Was ist eine Java Virtual Machine (JVM) Autor: Hubert Partl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Die JVM ist eine die Software, die notwendig ist, um ein Java- Binärprogramm (Bytecode) auf einem Computer auszuführen. Der Name bedeutet virtuelle Java-Maschine und kommt daher, dass der Computer, der direkt nur Windows- oder Macintosh- oder Unix-Binärprogramme ausführen kann, mit Hilfe der JVM so wirkt, als ob er Java-Bytecode ausführen könnte, also als ob er eine Java-Maschine wäre. 3.11.4. Wie konfiguriere ich JDK1.3/1.4 unter Linux oder Unix? Autor: Martin Erren, Michael Paap ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Frage: Bei meinem Linux ist per default kaffe (jdk1.1.8) eingestellt, obwohl ich das Sun jdk installiert habe. Wie kann ich 1.3 unter Linux benutzen? Antwort: Die default-Einstellungen sind gut für jene, die nur GNU-Lizenzen akzeptieren, aber schlecht für solche, die ernsthaft in Java entwickln oder anspruchsvolle Java-Programme benutzen wollen. I. SuSE Linux SuSE macht die Umstellung auf das aktuelle Sun-jdk wenigstens einfach. Sie muss jedoch per Hand erfolgen. Ein normaler Benutzer hat /usr/lib/java/bin im $PATH. (Unter root braucht/soll Java nicht gestartet werden) /usr/lib/java ist ein symbolic link auf /usr/lib/jdk1.1.8, eine Variante vom jdk 1.1.8 namens kaffe. Man vergewissere sich dessen mit # file /usr/lib/java Falls tatsächlich ein symbolic link, kann man diesen getrost (unter root) mit # rm /usr/lib/java löschen und mit # ln -s /usr/java/jdk1.3.1_01 /usr/lib/java auf das Sun jdk neu verlinken. Weiterhin sollte man in /etc/rc.config die Variable CREATE_JAVALINK auf "no" setzen, sonst setzt SuSEConfig den Link wieder in den Urzustand, wenn es das nächste Mal läuft. Diese Angaben gelten für SuSE 7.3 und können pro Distributions-Version geringfügig von der beschriebenen Struktur abweichen. (Falls Dir symbolic links, file, rm, $PATH nichts sagen, solltest Du Dir eine kleine Einführung in UN*X besorgen, zum Beispiel [...]) II. Unix/Linux Allgemein Da andere Linux Distributionen nicht so verbreitet sind wie SuSE, können hier kaum alle Originalkonfigurationen durchgegangen werden. Bei allen UN*X Varianten kann man aber immer so analysieren: * Mit "java -version" die installierte JRE überprüfen. * Mit "type java" erkennen ob "java" ein alias, oder eine ausführbare Datei ist, bzw. wo sie im Filesystem liegt. * Mit "file .../java" erkennen, ob es sich um ein script oder eine binary handelt. Und so zu einem installierten Sun-JDK umlenken ($JAVA_HOME sei das installierte Sun JDK): * Den $PATH ändern, Eintrag auf $JAVA_HOME/bin *vor* der Original- Binary * "alias" setzen (hat immer Vorrang). * Etwaige links umbiegen wie oben beschrieben. Die Variable $JAVA_HOME sollte man ebenfalls setzen, da einige Programme so das installierte JDK finden (z.B. Tomcat). 3.11.5. Wie installiere und konfiguriere ich das jdk unter Windows 9x/Me/NT/2000 richtig? Autor: Wolfgang Schirmer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Als Referenz-jdk nehmen wir das jdk1.3.1 ! Nach dem Download des jdk 1.3.1 wird die Installationsroutine über den klick auf die jdk1_3_1-win.exe gestartet. Nach der Begrüssung und den Auszug aus den Lizenzbedingungen erfolgt die Auswahl des Installations- verzeichnisses. Standardmässig wird das Verzeichnis C:\jdk1.3.1 vorgeschlagen. Dies kann aber über Browse geändert werden. Nach der Festlegung des Installationsumfanges werden die Dateien auf die Festplatte kopiert. Durch die Eingabe des Kommandos: java -version in der DOS-Box kann festgestellt werden welche Version auf dem System installiert wurde. Für dieses Beispiel sollte folgende Nachricht als Reaktion auf das Kommando erscheinen: java version "1.3.1" Als nächstes sind die PATH-Einstellungen zu überprüfen. Hierbei ist es wichtig zu wissen, dass die PATH-Anweisung die Pfade festlegt, in denen das Betriebssystem nach Programmen sucht. Unter Windows 9x/Me wird die Pfadeinstellung in der autoexec.bat durchgeführt. Hier sollte die PATH-Zeile folgendermassen aussehen: PATH=C:\WINDOWS;C:\WINDOWS\COMMAND;C:\jdk1.3.1\bin Nach dieser Änderung in der autoexec.bat muss das System neu gestartet werden, damit die Änderungen auch wirksam werden. Unter WindowsNT/2000 ist die Pfadeinstellung in der Systemsteuerung|System|Umgebung innerhalb der Systemvariablen vorzunehmen. Hier ist der Eintrag in der Variablen PATH durch die Zuweisung: ;C:\jdk1.3.1\bin zu ergänzen. Die Änderungen werden erst in den nach der Änderung geöffneten DOS-Box wirksam. Achtung! Um unter WinNT/2000 diese Einstellungen vornehmen zu können muss man die Administrator- Berechtigung besitzen. 3.12. [TOOLS] - Frage zu einem Java-Zusatz-Tool, zum Beispiel IDEs, Build-Tools, Profiler, etc. ------------------------------------------------------------------- 3.12.1. Welche IDE muss ich verwenden? Autor: Martin Erren ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ <URL:http://groups.google.com/groups?q=beste+%2B+IDE+%2B+Java ++-emacs+-vi+-vim+-notepad+group%3Ade.comp.lang.java&hl=de&btnG =Google-Suche> BTW: Der Link muss aus den 3 Zeilen zusammengesetzt werden ! Bietet eigentlich jederzeit einen guten Überblick. 3.12.2. Wie kann man eine Java-Anwendung in eine EXE-Datei umwandeln? Autor: Marco Schmidt ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ein nativer Compiler ist in der Lage, Quelltext oder Bytecode in eine native Anwendung (statt wie üblich bei Java in Bytecode, also .class-Dateien) umzuwandeln, etwa eine EXE-Datei unter Windows. Auf <URL:http://www.geocities.com/marcoschmidt.geo/java-native-compilers.html #products> sind u. a. auch einige native Compiler und weiterführende Links zum Thema "native compilation" aufgelistet. BTW: Der Link muss aus 2 Zeilen zusammengesetzt werden ! Bei der Verwendung gibt es allerdings ein paar Punkte zu beachten. * Gute native Compiler sind recht teuer und somit nur im professionellen Umfeld sinnvoll einsetzbar. Der freie native Compiler gcj unterstützt z. B. nur Java 1.1, und auch das nur teilweise (kein AWT etc.). * Obwohl das vom nativen Compiler erzeugte Programm aus nativem Code besteht, muß oft trotzdem noch ein Java Runtime Environment installiert werden, so daß der Vorteil der einfachen Verteilung des Programms wegfällt - der Benutzer könnte genauso gut direkt das JRE installieren und die Bytecode-Version der Anwendung starten. * Der große Geschwindigkeitsvorteil durch nativen Code existiert heutzutage nicht mehr, da moderne JVMs durch Just-in-time-Compiler in den meisten Fällen sehr nah an nativen Code herankommen. In Einzelfällen mag es aber durchaus Vorteile bei nativem Code geben. * Da es native Compiler nicht für all diejenigen Plattformen gibt, für die auch JREs existieren, schränkt man die Anzahl potentieller Nutzer ein, wenn man auf nativen Code besteht. Allerdings dürften mit nativen Compilern für Windows und ein paar der verbreiteteren Unix-Varianten absolut gesehen der größte Teil aller Computerbenutzer abgedeckt sein. * Wer nativen Code verwendet, muß eventuell mehrere Versionen des Programms für verschiedene Plattformen pflegen. Durch die Verwendung von Bytecode (.class-Dateien) hat man eine Version, die überall ausgeführt werden kann ("write once, run anywhere"). Zum Schluß noch ein paar Vorteile durch die Verwendung eines nativen Compilers. * Native Programme starten meist schneller - dies ist für lang laufende Server-Anwendungen nicht so wichtig, für häufig aufgerufene Kommandozeilenprogramme allerdings schon eher. * Es ist schwerer, nativen Code als Bytecode zu dekompilieren (also wieder den Quelltext zu erhalten). Wer also Reverse-engineering seines Programms fürchtet, hat bei Bytecode mehr Anlaß zur Sorge. * Einige native Compiler ermöglichen es, daß gleichzeitig laufende Instanzen der erzeugten Programme sich gewisse Ressourcen teilen und so weniger Arbeitsspeicher verbrauchen. Aktuelle JVMs laufen stets völlig unabhängig voneinander ab (dies wird sich vielleicht nach Java 1.4 ändern). Man kann mit nativen Anwendungen also mehr Instanzen eines Programms auf demselben System laufen lassen. Native Compiler haben in einigen Nischen also durchaus Daseinsberechtigung. Allerdings sollte, wer sich um einfache Verteilung seines Programms Gedanken macht, eine der folgenden Möglichkeiten in Betracht ziehen: * Suns Java Webstart <URL:http://java.sun.com/products/javawebstart/> * Ausführbare JAR-Dateien, die sich mit einem Doppelklick auf das entsprechende Icon starten lassen <URL:http://java.sun.com/products/jdk/1.2/docs/guide/extensions/ spec.html#executable> * Einen Installer wie InstallAnywhere <URL:http://www.zerog.com/>, JExpress <URL:http://www.denova.com/> oder eines der Produkte aus dem entsprechenden Abschnitt des Open Directory: <URL:http://dmoz.org/Computers/Programming/Languages/Java/ Development_Tools/Deployment/> 3.13. [MATH] - Mathematik, Arithmetik, Gleitpunktzahlen, Funktionen. -------------------------------------------------------------------- 3.13.1. Warum rechnet Java falsch? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem: public class Test { public static void main(String[] args) { float zahl = 0.0F; for (int i = 0; i <= 100; i++) { System.out.println(zahl); zahl += 0.1F; } } } Läßt man obiges Programm laufen so ergibt sich folgende Ausgabe: 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.70000005 0.8000001 0.9000001 ... Scheinbar rechnet Java an einigen Stellen falsch und ist nicht fähig, zu einer Zahl den Wert 0.1 korrekt zu addieren. Dies sieht jedoch nur so aus und ist auch keineswegs typisch für die Programmiersprache Java, sondern ein allgemeines Problem. Zahlendarstellung im Computer: Um dies zu verstehen, muß man sich klar machen, daß ganze Zahlen intern in Form von Binärzahlen und Fließkommazahlen mit Hilfe von Binärbrüchen dargestellt werden. Nun kann der (nicht gerade seltene) Fall eintreten, daß sich eine Zahl im Dezimalsystem zwar darstellen läßt, in Binärdarstellung jedoch zu einem unendlichen, nicht abbrechenden, Bruch wird. Für die Speicherung einer Zahl steht aber nur ein beschränkter Speicherplatz zur Verfügung, d.h. die unendliche Binärdarstellung wird nur bis zu einer gewissen Stelle gespeichert. Das Resultat sind Ungenauigkeiten. Addiert man jetzt solche Zahlen (und 0.1 ist ein Beispiel für so eine Zahl) mehrfach auf, so addieren sich die unvermeidbaren Ungenauigkeiten immer mehr auf und führen zu dem obigen Verhalten. Dies ist keineswegs charakteristisch für Java, sondern auch in jeder anderen Sprache, die Fließkommazahlen verwendet, reproduzierbar. Eine Abmilderung des Problems besteht in einer schlauen Rundung von Zwischenergebnissen an geeigneten Stellen der Berechnung, so daß Fehler kompensiert oder zumindest abgeschwächt werden. 3.13.2. Wie runde ich eine Gleitkommazahl? Wie formatiere ich eine Gleitkommazahl? Autor: Peter Luschny; Datum: 2004-02-04 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Runden und Formatieren von Gleitkommazahlen ::: 1. Einführung :::::::::::::::::::::::::::::::::::::::::::::::::::::::: Die Dezimaldarstellung einer Zahl a notieren wir (die Schreibweise a_{i} bedeutet dabei "a mit einem tiefgestellten Index i") a = ± a_n a_{n-1} ... a_0 , a_{-1} a_{-2} ... a{-k} wobei die a_i Ziffern '0','1,','2',...,'9' sind und a_n ungleich 0. Die rechts vom Vorzeichen stehenden Ziffern heißen die 'tragenden Stellen' von a, die rechts vom Komma stehenden Ziffern 'Nachkommastellen' von a. Jede Zahl a ungleich 0 kann eindeutig in der Form dargestellt werden a = m * 10^q, wobei 1 <= |m| < 10 und q eine ganze Zahl ist. Diese Darstellung nennen wir die Gleitkommadarstellung von a. Beispiel: Die Dezimalzahl 123,45678 hat die Gleitkommadarstellung 1,2345678 * 102. Will man auf 2 /Nachkommastellen/ runden, so möchte man die Dezimaldarstellung 123,46 erhalten, will man auf 2 /tragende Stellen/ runden, so möchte man die Gleitkommadarstellung 1,2 * 102 erhalten. Die Java-Dokumentation wählt noch eine andere Umsetzung. Hier wird die Zahl aus dem Beispiel als [12345678, 5] dargestellt und allgemein die Notation [m,s] verwendet, wobei a = m*10^(-s). Hier geht man also von der Anzahl der Nachkommastellen aus (deren Endlichkeit vorausgesetzt wird), und es wird von rechts nach links abgezählt (man beachte das Minus- Zeichen des Exponenten). Wir haben also die 3 Darstellungen 123,45678 = 1,2345678 * 102 = [12345678, 5] In einem Computer sind natürlich nur endlich viele Gleitkommazahlen darstellbar. In der Mathematik gibt es aber unendlich viele. Will man also das mathematische Rechnen auf einem Computer 'simulieren', muss man ständig versuchen, trotz dieses Umstandes möglichst nahe an den 'wahren' Werten zu bleiben. Dieses Auswählen eines geeigneten Stellvertreters unter den im Rechner darstellbaren Zahlen ist es, was man, allgemein gesprochen, 'Runden' nennt, und diese Operation ist im Grunde vor und nach jeder arithmetischen Operationen notwendig, wenn man sicherstellen will, dass die Gesetze der Mathematik nicht verletzt werden. Die bekanntesten Arten zum Runden sind: den 'oberen' Nachbarn, den 'unteren' Nachbarn oder die 'nächstliegende' Zahl im System der darstellbaren Gleitkommazahlen auszuwählen. Neben dem Runden einer Gleitkommazahl gehört zu den Standardaufgaben sie geeignet zu 'formatieren'. Hier entscheidet man über die graphische Darstellung einer Ziffernfolge beim Anzeigen oder Ausdrucken. Beide Operationen sind begrifflich unabhängig voneinander, werden aber manchmal verwechselt - dies ist einer der Gründen, warum wir sie hier gemeinsam besprechen. Das Ergebnis einer Rundung ist ein 'double', das Ergebnis einer Formatierung ein 'String'. Für beide Operationen stellt die Java-Bibliothek Klassen zur Verfügung. Für das Rechnen und Runden: 'java.math.BigDecimal', Für das Formatieren: 'java.text.DecimalFormat'. Die folgenden Vorschläge setzen eine Version des JDK >= 1.5 voraus. Wie komplex die Dinge sind, zeigt, dass die Dokumentation von BigDecimal in der Version 1.5 allein 41 Seiten, die von 'DecimalFormat' 22 Seiten lang ist. Es wird daher dringend empfohlen, diese Dokumentation zu lesen. ::: 2. Das Runden einer Gleitkommazahl :::::::::::::::::::::::::::::::: Eine wichtige Art, Gleitkommazahlen in Java in den Griff zu bekommen, ist es, die Klasse BigDecimal zu verwenden. Dies bietet Vorteile gegenüber dem direkten Arbeiten mit 'doubles': In den Feinheiten und Sonderfällen der Gleitkomma-Arithmetik sind viele Fußangeln versteckt, ihnen durch den Gebrauch der Bibliotheksfunktionen aus dem Weg zu gehen, ist ein guter Rat nicht nur für Anfänger. Folgende einfache Funktion zum Runden einer Gleitkommazahl zeigt, wie man dabei vorgehen kann. ////////////////////////////////////////////////////////////////////////// public static double round (double d, int scale, RoundingMode mode, FormatType type) { if (Double.isNaN(d) || Double.isInfinite(d)) return d; scale = Math.max(scale,0); // Verhindert negative scale-Werte BigDecimal bd = BigDecimal.valueOf(d); if(type == FormatType.exp) { BigDecimal bc = new BigDecimal(bd.unscaledValue(),bd.precision()-1); return ((bc.setScale(scale, mode)). scaleByPowerOfTen(bc.scale()-bd.scale())).doubleValue(); } return (bd.setScale(scale, mode)).doubleValue(); } ////////////////////////////////////////////////////////////////////////// Kurzbeschreibung der Funktion: /** * @param d der zu rundende Gleitkommawert. * @param scale die Anzahl der Nachkommastellen, falls type = fix, * die Anzahl der tragenden Stellen - 1, falls type = exp. * scale sollte >= 0 sein (negative Werte werden auf 0 gesetzt). * @param mode die Rundungsart: einer der Rundungsarten von BigDecimal, * seit 1.5 in java.math.RoundingMode. * @param type ein Element von "enum FormatType {fix, exp}" gibt an, * auf welche Stellen sich die Rundung beziehen soll. * FormatType.exp ('Exponential') steht für tragende Stellen, * FormatType.fix ('Fixkomma') steht für Nachkommastellen. * @return der gerundete Gleitkommawert. * <p>Anmerkung: Für die Werte <tt>double</tt> NaN und ±Infinity * liefert round den Eingabewert unverändert zurück. */ Beispiel: d = -Math.exp(702); for (int scale = 0; scale < 6; scale++) System.out.println(round(d,scale,RoundingMode.HALF_EVEN,FormatType.exp)); 0 -> -7.0E304 1 -> -7.5E304 2 -> -7.49E304 3 -> -7.494E304 4 -> -7.4942E304 5 -> -7.49422E304 Beispiel: d = Math.PI*10000.0; for (int scale = 0; scale < 6; scale++) System.out.println(round(d,scale,RoundingMode.HALF_EVEN,FormatType.fix)); 0 -> 31416.0 1 -> 31415.9 2 -> 31415.93 3 -> 31415.927 4 -> 31415.9265 5 -> 31415.92654 Die Enumeration "enum FormatType {fix, exp};" muss dabei selber definiert werden. Man beachte auch die Verwendung der Factory-Methode valueOf(). Diese Form ist in der Regel dem Konstruktor 'BigDecimal(double val)' vorzuziehen. Man lese dazu die Erläuterungen in der Dokumentation (Version >= 1.5) von BigDecimal. "This is generally the preferred way to convert a float or double into a BigDecimal.." Ein einfaches Beispiel veranschaulicht den Unterschied: System.out.println(BigDecimal.valueOf(1.005)); System.out.println(new BigDecimal(1.005)); >>>> 1.005 >>>> 1.00499999999999989341858963598497211933135986328125 In Java-Versionen vor 1.5 läßt sich BigDecimal.valueOf(d) simulieren durch new BigDecimal(Double.toString(d))). Der 'if'-Zweig der Funktion 'round' ist allerdings in älteren Versionen nicht (so einfach) zu erhalten: Die Funktionen precision() und scaleByPowerOfTen() sind erst ab 1.5 im API enthalten und müssten bei älteren Versionen 'nachgebaut' werden. Entweder eine nette Übungsaufgabe oder ein guter Grund, auf eine Version >= 1.5 umzusteigen. BigDecimal stellt 8 Möglichkeiten zur Rundung zur Verfügung. Will man auf 2 Stellen im 'kaufmännischen Sinn' runden, so wähle man HALF_UP. Der IEEE-Standard sieht diese Rundung allerdings nicht als den Normalfall an, und bei numerischen Rechnungen wählt man besser HALF_EVEN. Gebrauchsfertig in handliche Makros gepackt: public static double roundUpFix2 (double d) { return round (d, 2, RoundingMode.HALF_UP, FormatType.fix); } public static double roundEvenExp2 (double d) { return round (d, 2, RoundingMode.HALF_EVEN, FormatType.exp); } ::: 3. Das Formatieren einer Gleitkommazahl ::::::::::::::::::::::::::: Für das Formatieren ist 'java.text.DecimalFormat' das angebotene Werkzeug. Eine kleine Utility-Funktion 'format' mit einer ähnlichen Aufrufstruktur wie die Funktion 'round', zeigt hier einen Ansatz: ////////////////////////////////////////////////////////////////////////// public static String format (double d, int scale, FormatType type) { if (Double.isNaN(d) || Double.isInfinite(d)) return Double.toString(d); scale = Math.max(scale,0); // Verhindert negative scale-Werte DecimalFormat df = new DecimalFormat(); df.setMaximumFractionDigits(scale); df.setMinimumFractionDigits(scale); if( type == FormatType.exp ) { StringBuilder sb = new StringBuilder("0E0"); if(scale > 0) sb.append(".000000000000000000",0,scale+1); df.applyPattern(sb.toString()); } else { df.setGroupingUsed(false); df.setMinimumIntegerDigits(1); } return df.format( d ); } ////////////////////////////////////////////////////////////////////////// Kurzbeschreibung der Funktion: /** * @param d der zu formatierende Gleitkommawert. * @param scale die Anzahl der Nachkommastellen, falls type = fix, * die Anzahl der tragenden Stellen - 1, falls type = exp. * scale sollte >= 0 sein (negative Werte werden auf 0 gesetzt). * @param type ein Element von "enum FormatType {fix, exp}". * FormatType.exp fordert eine eine wissenschaftliche Exponential- * darstellung an, FormatType.fix fordert ein Fixkommaformat an. * @return eine Zeichenkette, die den Gleitkommawert darstellt und entsprechend den gewünschten Parametern formatiert ist. * <p>Anmerkung: Für die Werte <tt>double</tt> NaN und ±Infinity * liefert diese Methode {@link Double#toString} zurück. */ Auch hier muss die Enumeration "enum FormatType {fix, exp};" selber definiert werden. Man beachte bei den folgenden Beispielen die Verwendung von ',' anstelle von '.' bei der Ausgabe. Wir bekommen also in der Tat Gleitkommazahlen und nicht Gleitpunktzahlen geliefert, wie sich das auch gehört, wenn die 'lokalen Einstellungen' auf Deutschland gesetzt sind. Wer arabische oder indischen Ziffern bevorzugt, kann auch dies erreichen - zur Verwendung von 'Locales' im Zusammenhang mit DecimalFormat verweisen wir auf die Dokumentation. Die beiden Beispiele von oben nehmen, mit den Voreinstellungen der deutschen Locale, folgende Gestalt an: Beispiel: d = -Math.exp(702); for (int scale = 0; scale < 6; scale++) System.out.println(scale+" -> "+format(d, scale, FormatType.exp)); 0 -> -7E304 1 -> -7,5E304 2 -> -7,49E304 3 -> -7,494E304 4 -> -7,4942E304 5 -> -7,49422E304 Beispiel: d = Math.PI*10000.0; for (int scale = 0; scale < 6; scale++) System.out.println(scale+" -> "+format(d, scale, FormatType.fix)); 0 -> 31416 1 -> 31415,9 2 -> 31415,93 3 -> 31415,927 4 -> 31415,9265 5 -> 31415,92654 Bequeme Makros machen die Funktion jetzt gebrauchsfertig: public static String formatFix2 (double d) { return format (d, 2, FormatType.fix); } public static String formatExp2 (double d) { return format (d, 2, FormatType.exp); } In vielen Anwendungen sind die Anforderungen an die Formatierung jedoch wesentlich komplexer, weil dabei auch der für die Anzeige zur Verfügung stehende Platz berücksichtigt werden muss. Eine Basisklasse dafür, die sich auch für eigene Experimente eignet, kann man hier finden: <URL:http://www.javajungle.de/OpenSource/DecimalFormat/> ::: 4. Runden plus Formatieren ::::::::::::::::::::::::::::::::::::::::: Als letztes eine Warnung: DecimalFormat verwendet /intern/ auch eine Rundung, und zwar - fest verdrahtet - RoundingMode.HALF_EVEN. Das ist schwerlich etwas anderes als ein Design-Bug, denn damit wird die Verwendung der 7 anderen Rundungsarten von BigDecimal in Verbindung mit dieser Formatierungsklasse problematisch. Insbesondere sollte jeder, der DecimalFormat verwendet, sich klar darüber sein, dass hier nicht kaufmännisch gerundet wird! Dazu noch ein Beispiel: Das einfache dform2 = new java.text.DecimalFormat("0.00") beschert folgende 'Überraschung' beim Ausdruck einer Rechnung: dform2( 10.495 ) -> 10,50 dform2( 10.505 ) -> 10,50 dform2( 10.515 ) -> 10,52 Zum Glück beißt sich die interne Rundung von DecimalFormat nicht mit einer vorgeschalteten Aufrundung, sofern es nur um das Formatieren geht, so dass sich dieses Problem so lösen läßt: public static String formatFixUp2 (double d) { return formatFix2(roundUpFix2(d)); } formatFixUp2( 10.495 ) -> 10,50 formatFixUp2( 10.505 ) -> 10,51 formatFixUp2( 11.515 ) -> 11,52 Aber dieses Beispiel ist in erster Linie zur Illustration des Gesagten gedacht. Denn bei kaufmännischen Rechnungen gilt es die Maxime von Paul Ebermann zu befolgen: "Beim Rechnen mit Geld verwende man NIE 'double'." Zu diesem Thema lese man auch den zweiten Link, der unten angegeben ist. ::: 5. Zusammenfassung :::::::::::::::::::::::::::::::::::::::::::::::::: ---------------------------------------------------- RUNDEN | FORMATIEREN ---------------------------------------------------- d = PI*10000.0; Nachkomma-Stellen | Fixpunkt-Format roundUpFix2(d) | formatFix2(d) Wert: double 31415.93 | Wert: String "31415,93" ---------------------------------------------------- d = -exp(702); Tragende Stellen | Exponential-Format roundEvenExp2(d) | formatExp2(d) Wert: double -7.49E304 | Wert: String "-7,49E304" ---------------------------------------------------- In dieser Gegenüberstellung wurde der Einfachheit willen ein Spezialfall gewählt, für die allgemeine Darstellung gilt Analoges. ::: 6. Links und Literatur ::::::::::::::::::::::::::::::::::::::::::::::: *** Zur Verwendung der API: <URL:http://java.sun.com/docs/books/tutorial/i18n/format/ decimalFormat.html> <URL:http://www.javaworld.com/javaworld/jw-06-2001/jw-0601-cents_p.html> *** Grundsätzliches zur (dezimalen) Gleitkomma-Arithmetik: <URL:http://www2.hursley.ibm.com/decimal/decimal.html> <URL:http://www2.hursley.ibm.com/decimal/decifaq.html> 3.13.3. Wie kann ich in Java Zufallszahlen im Bereich 0..n erzeugen? Autor: Markus Reitz, Uwe Günther ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Zur Erzeugung von Zufallszahlen bietet Java das Random-Objekt. Bevor Zufallszahlen erzeugt werden können, muß ein solches Objekt erzeugt werden, wobei ein Random-Seed genannter Zahlenwert übergeben wird, der Anteil an der Berechnung von Zufallszahlen hat. Generell muß man sagen, daß es sich bei auf dem Computer erzeugten Zufallszahlen um keine echten zufälligen Zahlenfolgen handelt, der Begriff Pseudo-Zufallszahlen trifft das Ganze besser. Grundlage dieser Zahlen sind Generator-Funktionen, die eine mehr oder minder zufällig erscheinende Folge von Zahlen erzeugen. Für die Berechnung der Zahlen spielt der Random-Seed (quasi der Samen für die Berechnung) eine große Rolle. Wird dieser Random-Seed möglichst zufällig gewählt, so sind die resultieren-den Zahlenfolgen beinahe echte Zufallszahlen. In der Praxis hat es sich als brauchbar erwiesen, als Random-Seed die jeweils aktuelle Systemzeit zu benutzen, damit gewährleistet ist, daß sich der Seed möglichst häufig ändert. Damit erzeugt man ein Random-Objekt am Besten wie folgt: Random zufall = new Random(System.currentTimeMillis()); oder Random zufall = new Random(); Wobei der Default-Kostruktor intern auch nur this(System.currentTimeMillis()); aufruft, wie die Firma Sun in ihrer Online Dokumentation schreibt. Mit Hilfe der Member-Funktion nextInt() wird die nächste erzeugte Integerzahl geliefert. In einem Großteil der Fälle möchte man jedoch nicht Integerzahlen haben, die auch negative Werte annehmen können, sondern Zahlen im Bereich von 0 bis n. Hier kommt eine Variation der nextInt() Methode ins Spiel, deren Anwendung die folgende Zeile demonstriert: zahl = zufall.nextInt(n+1); Ist einem die Saat von Random nicht zufällig genug, dann sollte man die Klasse SecureRandom aus dem Package java.security verwenden. Hier werden unter anderem je nach Plattform Betriebsystem spezifische Mechanismen gewählt, wie zum Beispiel unter UNIX /dev/urandom. 3.14. [MISC] - Alles, was nicht in eine der anderen Rubriken paßt. ------------------------------------------------------------------ 3.14.1. Ich komme mit dem import-Statement nicht klar, was mache ich falsch? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem: In einem Programm kommen folgende beide import-Statements vor: import java.awt.*; import java.awt.event.*; Warum reicht nicht das erste Statement aus, um die nötigen Klassen und Interfaces zu importieren? Intuitiv würde man sagen, daß mit Hilfe des * alle Klassen und Interfaces importiert werden, die unterhalb des Pfades java.awt stehen, doch leider ist dies nicht so. Mit import java.awt.*; werden nur alle Klassen importiert, die im Verzeichnis java.awt stehen, nicht jedoch Klassen, die noch tiefer verschachtelt abgespeichert sind. Deshalb ist das zweite import-Statement nötig, welches alle Klassen in java.awt.event importiert. 3.14.2. Warum gibt es Probleme bei final Werten in Verbindung mit elementaren Typen? Autor: Markus Reitz, Paul Ebermann ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Angenommen, eine Klasse A ist wie folgt definiert: public class A { final static boolean test = true; } Aus irgendeinem Grund wird die Definition der Klasse A auf Folgendes geändert: public class A { final static boolean test = false; } Die Klasse A wird neu compiliert und eine neue Klassendatei erzeugt. Alle anderen Klassen, die das in Klasse A definierte Feld verwenden, müßten nun mit dem korrigierten Wert false arbeiten. Probiert man dies in der Praxis aus, so stellt man fest, daß dies nicht der Fall ist. Der Grund liegt in der Sprachdefinition der Sprache Java. Ein primitiver (elementarer) Datentyp, der das Modifiziererpaar final static trägt, wird vom Compiler als Konstante behandelt und kann überall, wo er im Programm auftritt, vom Compiler direkt durch den Wert ersetzt werden. Um also zu erreichen, daß sich die in der Klasse A gemachte Änderung auf alle sie benutzenden Klassen auswirkt, müssen alle betroffenen Klassen neu übersetzt werden. Dies gilt aber nur, wenn der Wert tatsächlich mit einer Compile-Zeit-Konstante initialisiert wird. Ein Ausweg aus diesem Dilemma stellt hier die Verwendung des Typ sicheren enum (type safe enum) dar, siehe weiter unten. Eine weitere Typ sichere Variante findet sich in folgendem Beispiel: public class A { final static boolean test = new Boolean(true).booleanValue(); } Geändert dann: public class A { final static boolean test = new Boolean(false).booleanValue(); } 3.14.3. Was bedeuten "$" im Namen von Class-Files? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das Dollarzeichen innerhalb eines Klassennamens taucht auf, wenn innere Klassen, also Klassen, die innerhalb einer anderen Klasse definiert sind, verwendet werden. Somit ist Testklasse$InnereKlasse.class die Class-Datei der inneren Klasse "InnereKlasse", die innerhalb der Klasse Testklasse definiert worden ist. 3.14.4. Wie lassen sich Bilder im Dateiformat XYZ laden oder speichern? Autor: Marco Schmidt ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Seit Java 1.0 lassen sich mit java.awt.Toolkit GIF- und JPEG-Dateien laden, seit Version 1.3 auch PNG (genaugenommen nicht nur aus Dateien, sondern von beliebigen URLs und sogar aus Byte-Arrays). Das Speichern von Bildern in diesen oder anderen Formaten wird nicht unterstützt. Da weder java.awt.Image noch java.awt.image.BufferedImage die Schnittstelle Serializable implementieren, lassen sich auch die eingebauten Routinen zum Objekt-I/O nicht verwenden. Eine Notlösung stellt eventuell die Verwendung von PixelGrabber bzw. MemoryImageSource aus java.awt.image dar. Mit ersterem lassen sich Pixel als RGBA-int-Werte aus einem beliebigen java.awt.Image-Objekt extrahieren, mit letzterem erzeugt man ein Image-Objekt aus solchen "int-Pixeln". Lesen und Schreiben von int-Arrays unterstützen u. a. DataIn/OutputStream bzw. ObjectIn/OutputStream. Dabei ist zu bedenken, daß dieser Ansatz vier Bytes pro Pixel verbraucht. Eventuell führt die zusätzliche Verwendung von java.util.zip.DeflaterOut/InflaterInputStream zu Einsparungen. Für gängige Dateiformate sind zahlreiche externe Lösungen verfügbar, sowohl frei als auch kommerziell, in stark unterschiedlicher Qualität. Unter <URL:http://www.geocities.com/marcoschmidt.geo/java-image-coding.html> befindet sich eine Liste. Die Bibliothek JIMI <URL:http://java.sun.com/products/jimi/> ist ein guter Einstiegspunkt, sie ist (seit Sun sie aufgekauft hat) kostenlos erhältlich und deckt eine größere Anzahl Formate ab. Das Package com.sun.image.codec.jpeg - zum Laden und Speichern von Bildern im JPEG-Format - ist in neueren Sun-JREs und JDKs enthalten, man kann sich jedoch nicht darauf verlassen, es auch in anderen Java-Distributionen zu finden. Bei Verwendung des LZW-Algorithmus' (z. B. in GIF bzw. TIFF/LZW) ist darauf zu achten, daß sowohl kommerzielle als auch Freeware-Produkte in bestimmten Ländern (inkl. USA und Deutschland) eine Lizenz beim Patentbesitzer Unisys erwerben müssen (siehe auch <URL:http://dmoz.org/Computers/Data_Formats/Graphics/2D/GIF/>. Als Alternative zu GIF ist PNG gut geeignet, da es GIFs Einsatzgebiet - mit Ausnahme von Animationen - abdeckt und in modernen Browsern unterstützt wird. Mit Java 1.4 wurde ein eigenständiges Package zum Laden und Speichern eingeführt: javax.imageio. Dieses unterstützt zunächst nur das Lesen von GIF, JPEG und PNG sowie das Schreiben von JPEG und PNG. Allerdings plant Suns JAI-Team (Java Advanced Imaging, eine Java-Bibliothek für Bildverarbeitung), fast alle Codecs aus JAI zu portieren, so daß sie der Spezifikation von javax.imageio folgen. Das schließt BMP, PNM (Portable Anymap) und TIFF ein. In Zukunft soll JAI für Codecs komplett auf die ImageIO-API aufbauen. Eine Einführung befindet sich auf <URL:http://java.sun.com/j2se/1.4/docs/guide/imageio/> oder bei installiertem JDK unterhalb des Installationsverzeichnisses in /docs/guide/imageio/index.html. Auf <URL:http://www.jalice.net/myJava.htm> finden sich zahlreiche Code-Beispiele und weiterführende Informationen zum Umgang mit Bildern, Java2D und der neuen ImageIO-API. 3.14.5. Was geht nicht mit Java? Autor: Martin Erren ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Einige Features sind sehr systemnah und können wegen der Plattformunabhängigkeit von Java nicht direkt gelöst werden. Oft ist liegt dabei das eigentliche Problem eher im Ansatz, weil zu plattformspezifisch gedacht wird, statt gängige Java-Paradigmen umzusetzen. So sind z.B. Properties jederzeit Environment Variablen vorzuziehen. Ansonsten schafft ein entsprechendes System.exec(...) Abhilfe oder ein Bibliotheksaufruf, z.B. über JNI (Java Native Interface). Ein für jede Plattform einzeln zu lösendes Problem. Einige Bibliotheken wie JavaComm sind bereits für die verschiedensten Plattformen implementiert. CPU: Daten wie Taktfrequenz auslesen. Speicher: Gesamtgrösse ermitteln, direkt manipulieren. Laufwerke: Genauen Laufwerkstyp erkennen (CDRom,...) CD auswerfen Filesystem: Partitionsgrösse bestimmen. Linux: genauen file type feststellen (block/stream devices,...) einzelne Berechtigungen auslesen Windows: Verknüpfungen folgen Native Lösung: <URL:http://www.tolstoy.com/samizdat/jconfig.html> Textconsole: Bildschirm löschen cursor position setzen Farben Native Lösung: <URL:http://www.bmsi.com/tuipeer/> Pure java (über ANSI): <URL:http://purl.org/NET/ePaul/#pps> Desktop: Nicht reckeckige Fenster Native Lösung: <URL:http://www.l2fprod.com/software/skinlf/> Tray Icon Native Lösung beschrieben bei: <URL:http://www.nevaobject.com/_docs/_coroutine/coroutine.htm#example> Fenster immer im Vordergrund halten Native Lösung: <URL:http://www.mysrc.net/lib/java/MySRC-AlwaysOnTop-090.zip> Netzwerk, Schnittstellen: ICMP Serielle + Parralle Schnittstelle ansteuern Native Lösung: <URL:http://java.sun.com/products/javacomm/> Tastatur: SHIFT, CNTRL, ALT alleine gedrückt Windows Taste Standardeingabe ungepuffert lesen (statt flush bei \n) Maus: Scrollrad (möglich ab JDK 1.4) Native Lösung <URL:http://www.codeproject.com/java/mousewheel.asp> Betriebssystem: Environment-Variablen lesen(unmöglich seit 1.2)/schreiben. System-Shutdown. Windows: Registry lesen/schreiben (eingeschr. möglich ab JDK 1.4) Native Lösung: <URL:http://www.trustice.com/java/jnireg/> 3.14.6. Wie kann ich in meinem Java-Programm ein HTML-Dokument anzeigen lassen? Author: Marco Schmidt ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Es gibt zwei Lösungsansätze, das Einbinden von Java-Code, der dies leistet, oder das Aufrufen eines externen Programms (Browser). * Man kann das Dokument selbst in einer GUI-Komponente anzeigen lassen. Das hat den Vorteil, daß man unabhängig von externen Programmen ist. In der Standardbibliothek gibt es seit Java 1.2 in der Hierarchie javax.swing.text.html entsprechenden Code. Der ist allerdings nur für Swing-Oberflächen geeignet, nicht für AWT. Darüber hinaus wird nur HTML 3.2 unterstützt. * Eine Mischlösung ist die Verwendung eines reinen Java-Browsers wie HotJava <URL:http://java.sun.com/products/hotjava/3.0/>. Dieser Browser könnte - nach Klärung der rechtlichen Details - mit dem Programm ausgeliefert werden und müßte überall dort funktionieren, wo auch die eigene Java-Applikation ausgeführt wird. HotJava unterstützt auch nur HTML 3.2, benötigt aber nur das AWT und Java 1.1. * Eine ähnliche Lösung ist der ebenfalls in reinem Java geschriebene kommerzielle ICEbrowser: <URL:http://www.icesoft.no/ps_browser_overview.html>. * BrowserLauncher ist eine Java-Klasse (Freeware) zum Starten des Standard-Browsers: <URL:http://browserlauncher.sourceforge.net/> * Ein JavaWorld-Artikel versucht ebenfalls, den Standardbrowser zu finden und zu starten: "Java Tip 66: Control browsers from your Java application" <URL:http://www.javaworld.com/javaworld/javatips/jw-javatip66.html> * Die kommerzielle Bibliothek JConfig bietet Ähnliches, unter Verwendung von nativem Code: <URL:http://www.tolstoy.com/samizdat/jcdocs/overview.html#WBLaunch> 3.14.7. Unter Windows werden in der Konsole (DOS-Eingabeaufforderung) die Umlaute falsch ausgegeben. Wie kann ich das korrigieren? Author: Peter Karp ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Das Problem liegt in der verwendeten Codepage. Standardmäßig geht ein Java-Programm von der Codepage Latin1 aus, während in der Windows-Konsole eine andere Codepage (hier meist CP850) verwendet wird. Intern werden bei Java Zeichensätze in Unicode codiert. Zur Ausgabe muss das Java-Programm die Unicode-Kodierung in die passende Kodierung der aktuellen Codepage konvertieren, welche für ein Zeichen -- im Unterschied zu Unicode -- nur ein Byte verwendet. Die Umlaute liegen bei verschiedenen Kodierungen oft nicht an der gleichen Stelle. Die aktive Codepage kann unter Windows 2000/XP mit dem Befehl chcp bzw. unter Windowx 9x mit dem Befehl mode con:cp angezeigt werden. Standardmäßig ist bei einem deutschen Windows Codepage 850 (manchmal auch 437) in der Konsole aktiv. In den "normalen" Windows-Programmen wird immer der MS-ANSI-Zeichensatz (Codepage 1252) verwendet. MS-ANSI ist weitgehend mit Latin1, welches z.B. unter Linux verwendet wird, identisch. Die 7-Bit-ASCII-Zeichen und die deutschen Umlaute sind an den gleichen Stellen. Somit gibt es zwei grundlegend verschiedene Lösungen: 1) Man ändert die verwendete Codepage in Windows auf Codepage 1252 oder Latin1. a) Die Unix-Umgebung "Cygwin" für Windows benutzt Latin1 als Codepage. Cygwin findet man unter www.cygwin.com und stellt unter anderem die üblichen Unix-Tools und eine Shell zur Verfügung. b) Unter Windows 2000/XP kann mit dem Befehl chcp die aktive Codepage gewechselt werden. Dies alleine stellt aber noch nicht die korrekte Ausgabe der Umlaute sicher, da auch der verwendete Font die richtige Kodierung verwenden muss. Sinnvollerweise erstellt man sich eine Verknüpfung zu einem neuen Konsolenfenster, dass Codepage 1252 und einen dazu passenden Font verwendet, da man in den anderen Konsolenfenstern in der Regel wahrscheinlich weiterhin Codepage 850/437 verwenden will, um zu den DOS-Programmen kompatibel zu bleiben: 1. neue Verküpfung auf Desktop erstellen 2. Speicherort angeben: %SystemRoot%\system32\cmd.exe /k chcp 1252 3. Name angeben: Konsole1252 4. fertigstellen 5. Eigenschaften der Verknüpfung ändern und als Schriftart "Lucida Console" definieren. Optional gibt man noch den Pfad zu dem Verzeichnis mit den Java-Programmen bei "Ausführen in:" an. 6. fertig, das wars - wird der Shortcut nun für Java-Programme verwendet, gibts keine Probleme mehr mit Umlauten Der Font "Lucida Console" ist ein TrueType-Font im OpenType-Format, der die Unicode-Codierung unterstützt und daher die Zeichen für alle verfügbaren Codepages beinhaltet. Die sog. "Rasterschriftart" hingegen liegt immer in der OEM-Kodierung vor. Dabei ist die OEM-Kodierung, die Kodierung, die im jeweiligen Land für "DOS-Programme" üblich ist. Für Deutschland ist das Codepage 850, für Amerika Codepage 437 usw. Falls man das Aussehen der "Lucida Console" nicht mag, kann man einen neuen Font installieren, der das OEM-Flag gesetzt hat, aber trotz dieses Flags die Kodierung für Codepage 1252 verwendet. Diesen Font New1252.FON, und eine Erklärung wie dieser zu nutzen ist, findet sich auf der Homepage von <URL:http://www.uwe-sieber.de>. 2) Alternativ kann im Java-Programm selbst sichergestellt werden, dass die aktive Codepage zur Ausgabe berücksichtigt wird. Erstelle eine neue Klasse für dein Tool-Paket und rufe sie mit new KonsolenUmlaut(); auf, oder packe das folgende Code-Beispiel in die Klasse, die das Problem betrifft. Diese Möglichkeit sollte aber nicht fest codiert werden, sondern optional über ein Argument beim Start des Programmes mitgegeben werden können. Eine weitere Möglichkeit wäre die Ausgabe des Befehls 'mode con:cp' auszuwerten und dann die Codepage entsprechend zu übergeben. Code-Beispiel ============= /** * Gibt die Umlaute unter Windows in Codepage 850 aus. Eingabe von * der Konsole oder Dateioperationen sind davon unberührt und haben * auch die Umlaute korrekt nach Latin1. */ package myToolsPackage; import java.io.*; public final class KonsolenUmlaut { public KonsolenUmlaut() { String sys = System.getProperty("os.name"); if (sys.startsWith("Windows")) { try { System.setOut( new PrintStream( new FileOutputStream(FileDescriptor.out), false, "cp850")); System.setErr( new PrintStream( new FileOutputStream(FileDescriptor.err), true, "cp850")); } catch (IOException e) { e.printStackTrace(); } } } } 3.15. [ERROR] - Fehlermeldungen ------------------------------- 3.15.1. Warum findet Java den Konstruktor nicht? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem: public class Test { private int a; private int b; public void Test (int a , int b) { this.a = a; this.b = b; } public static void main (String[] args) { //Und hier eine Fehlermeldung. Test myTest = new Test (12, 13); } } Versucht man die obige Klasse zu übersetzen, so meckert der Compiler mit der Meldung Wrong number of arguments in constructor ... . Die Lösung des Problems ist einfach: Konstruktoren besitzen keinen Rückgabetyp, auch nicht void. In obigem Beispiel hat man nämlich nicht den Konstruktor für die Klasse Test definiert, sondern eine Funktion, die den selben Namen wie die Klasse hat. Weiter unten versucht man nun, den vermeintlich definierten Konstruktor aufzurufen und bekommt die beschriebene Fehlermeldung. Lösung: public class Test { private int a; private int b; public Test (int a , int b) { this.a = a; this.b = b; } public static void main (String[] args) { //Hier kommt jetzt keine Fehlermeldung mehr! Test myTest = new Test (12 , 13); } } 3.15.2. Warum bekomme ich eine "NoClassDefFoundError" Fehlermeldung beim Starten von java? Autor: Markus Reitz, Sascha Raabe ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Der Grund ist einfach: Man muß der Java-Laufzeitumgebung mitteilen, wo sich die *.class-Dateien des Programms befinden, damit die Ausführung erfolgen kann. Dies erreicht man bei der SUN-Implementierung mit dem Aufrufparameter -cp für Classpath oder man setzt die Umgebungsvariable CLASSPATH auf das Verzeichnis, in dem sich die *.class-Dateien befinden. Ausserdem muss beim Aufruf des Programms der vollständige Klassenname angegeben werden. Dieser besteht aus Packagenamen und Name der Java Klasse. Beispiel: Die Java Klasse "MyApp" befindet sich im Package "de.foo.bar". Der Aufruf der Klasse erfolgt somit über: java de.foo.bar.MyApp Dabei ist auf Gross- und Kleinschreibung zu achten. 3.15.3. Warum bekomme ich eine "Couldn't read <Name>" Fehlermeldung beim Kompilieren mit javac? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In Java gilt die einfache Regel, daß der Name der Datei, in der die Klasse gespeichert ist, identisch mit dem Klassennamen sein muß, wobei auf die korrekte Groß- und Kleinschreibung zu achten ist. 3.15.4. Warum bekomme ich eine "class <Name> must be defined in a file called <Name>" Fehlermeldung beim Kompilieren von javac? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Hier gilt analog das unter dem vorherigen Punkt angeführte. Eine Datei, in der der Quelltext der Klasse gespeichert ist, muß den selben Namen besitzen wie die Klasse im Quelltext. 3.15.5. Warum wird beim Zugriff auf ein korrekt initialisiertes Objekt- Array eine NullPointerException geworfen? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Problem: public class A { public String text; } public class Test { public static void main (String[] args) { A array = new A[10]; for(int i = 0; i < 10; i++) { //wirft NullPointerException array[i].text = "Test"; } } } Führt man das Programm aus, so erhält man die im Programmtext erwähnte NullPointerException, obwohl doch alles eigentlich ganz in Ordnung aussieht. Der Teufel steckt aber im Detail. Mit A array[] = new A[10] wird eben nicht ein Array von zehn Objekten vom Typ A erzeugt, sondern nur ein Array, welches zehn Referenzen auf Objekte vom Typ A enthält, die eigentlichen Objekte werden damit nicht erzeugt. Lösung: public class A { public String text; } public class Test { public static void main (String[] args) { A array = new A[10]; for(int i = 0; i < 10; i++) { array[i] = new A(); //wirft keine NullPointerException mehr array[i].text = "Test"; } } } 3.15.6. Warum bekomme ich eine NullPointerException, wenn ich versuche, auf Methoden oder Attribute von in einem Array gespeicherten Objekten zuzugreifen? Autor: Michael Paap ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Vermutlich hast Du zwar den Array erzeugt, nicht jedoch die Objekte. Dann sind die Fields Deines Array mit null initialisiert, d.h. die Referenzen existieren zwar, nicht jedoch die referenzierten Objekte. Abhilfe: Um z.B. einen Array von sechs Buttons zu erzeugen, geht man so vor: Button[] myButtons = new Button[6]; for (int i = 0; i < myButtons.length; i++) { myButtons[i] = new Button(); } 3.15.7. Warum meckert der Compiler bei nicht initialisierten final Variablen Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ab Java 1.1 ist folgender Code gültig: public class Test { final int i; public Test(int i) { //finale Variable this.i wird mit dem Wert //von i initialisiert. this.i = i; } public Test() { //Fehler die finale Variable this.i muss auch in diesem //Konstruktor initialisiert werden. } } Es ist also möglich, Variablen mit finalen Werten zu erzeugen, deren finaler Wert beim ersten initialisieren der Variablen einmalig festgelegt werden kann. Allerdings kann dies nur innerhalb eines Konstruktors geschehen und es muß auf jeden Fall eine Initialisierung der Variablen erfolgen, denn ansonsten meldet der Compiler Fehler. 3.15.8. Was hat die Compilerfehlermeldung "... is deprecated" zu bedeuten? Autor: Markus Reitz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Diese Meldung erhält man normalerweise dann, wenn ältere Java-Programme mit einer neuen Version des Compilers übersetzt werden sollen. Die Meldung ist nur eine Warnung, also kein richtiger Fehler, die Funktionalität des Programms wird nicht beeinträchtigt. Die Methode, die bei der Meldung "... is deprecated" genannt wird, sollte aber nach Möglichkeit nicht mehr im Programm verwendet werden, da das Konzept der Klasse verändert wurde und deshalb die Methode unter Umständen in neueren Versionen nicht mehr implementiert sein wird. Treten also solche Meldungen beim Compilieren auf, so sollte man die entsprechenden Methoden durch die empfohlenen Varianten ersetzen, damit gewährleistet ist, daß das Programm auch mit späteren Versionen von Java einwandfrei übersetzt werden kann. 3.16. [ClassLoader] - Alles über Classloader -------------------------------------------- 3.16.1 Wie funktionieren Classloader? Autor: Ortwin Glück, Ulf Jaehrig, Patrick Roemer, Jan Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Für das Laden von Klassendefinitionen sind in Java Exemplare der Klasse java.lang.ClassLoader zuständig.[1] Jede Klasse ist assoziiert mit dem Classloader (kurz: CL), über den sie geladen wurde und kann über diesen im Zusammenhang mit ihrem voll qualifizierten Klassennamen eindeutig identifiziert werden. Klassen mit gleichem Namen aber unterschiedlichen CL gelten als verschieden; Casts zwischen den beiden Klassen funktionieren nicht. Da die Klasse ueblicherweise auch bei der equals()-Operation herangezogen wird, werden auch Objekte mit gleicher Struktur und gleichen Membern, deren Klassen gleiche Namen aber unterschiedliche CL haben, als unterschiedlich betrachtet. Die im System vorhandenen CL bilden eine baumartige Hierarchie, in der Anfragen nach oben weitergereicht werden können (und sollen), und die in einem 'obersten' CL (dem sog. Bootstrap-CL) wurzelt. Der Ladevorgang teilt sich üblicherweise auf in folgende Schritte: 1. Es wird eine Anfrage an den CL gestellt, entweder explizit über ClassLoader#loadClass(), indirekt über Class#forName() oder implizit durch Verwendung eines Klassennamens im Sourcecode. In den letzten beiden Fällen wird der CL der Klasse, auf der forName() aufgerufen wird bzw. derjenigen, aus welcher der gerade ausgeführte Code stammt, verwendet. 2. Der CL überprüft, ob die Klasse bereits von ihm geladen wurde. Falls ja, sollte er das entsprechende Klassenexemplar gecached haben[2] - dieses wird zurückgeliefert, fertig. 3. Der CL delegiert die Anfrage zunächst an den ihm übergeordneten CL, der wiederum bei Punkt 2 mit der Bearbeitung beginnt. Kann dieser ein Klassenexemplar liefern, wird dieses zurückgegeben - fertig. 4. Der CL holt den Bytecode - je nach CL kann dieser aus unterschiedlichen Quellen stammen: .class-datei, .jar-datei, URL, programmatisch generiertes Byte-Array, usw. 5. Der Bytecode wird per ClassLoader#defineClass() in ein Exemplar von java.lang.Class umgewandelt. 6. Gegebenenfalls werden referenzierte Klassen und Interfaces rekursiv geladen ('resolving'). (Wohlgemerkt: 'Der' CL einer Klasse ist derjenige in der Delegationskette, der sie tatsächlich geladen hat (Schritt 2 oder 5), nicht unbedingt derjenige, auf dem ursprünglich loadClass() aufgerufen wurde.) Diese Vorgehensreihenfolge ist zwar erwünscht, kann aber teilweise nicht erzwungen werden. Insbesondere der Vorrang der Delegation kann in seltenen Fällen ignoriert werden, so z.B. beim Webapp-CL von Tomcat[9]. Bei Vergleichen von Klassen oder Objekten, beim Laden von Ressourcen (s.u.), bei Singletons[7] und bei 'Typesafe Enumerations'[8] kann man unter unerwarteten CL-Bedingungen schweren Schiffbruch erleiden. Näheres zum CL-Mechanismus findet man z.B. bei [4], [5] und [6]. 3.16.2 Warum macht der Classloader im Servlet-Container Probleme? Warum funktioniert das Einlesen von Ressourcen ueber den Classloader bei mir nicht? Autor: Ortwin Glück, Ulf Jaehrig, Patrick Roemer, Jan Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Üblicherweise muss man sich nicht besonders oft mit CL befassen. Ausnahmen sind Probleme beim Laden von Ressourcen aus dem Classpath (=> dclj-FAQ 3.3.6.) und das Schreiben von Bibliotheken oder Klassen, die im Kontext CL-technisch komplizierterer Umgebungen wie J2EE- oder Servlet-Containern zur Anwendung kommen können oder sollen. Es gibt mehrere Möglichkeiten, direkt oder indirekt an unterschiedliche CL zu geraten: Über die Klasse, die den gerade ausgeführten Code enthält, über eine beliebige andere Klasse oder über Thread.currentThread().getContextClassLoader(). Üblicherweise will man sich möglichst tief in der CL-Hierarchie einklinken. In Servlet-Containern fährt man meist recht gut mit dem Context-CL des aktuellen Threads, da der Container sich drum kuemmert, dass dieser passend gesetzt ist, ebenso im Beispielcode. Anderswo ist das eine recht wacklige Angelegenheit, da dieser Context-CL praktisch beliebig gesetzt und wieder neu gesetzt werden oder auch null sein kann. Das Laden über eine bestimmte Klasse bringt hingegen Probleme, wenn deren CL kein Blatt der CL-Hierarchie darstellt und es möglich ist, dass dynamisch auf tieferliegende Elemente zurückgegriffen werden soll. Beispiel: Eine Klasse in einem shared- oder common-Verzeichnis eines Servlet-Containers will zur Laufzeit eine Webapp-spezifische Klasse laden. Ein weiteres Problem mit dem Einlesen von Ressourcen ueber den CL ist, dass man ggfs. die entsprechenden Security-Privilegien benoetigt. Diese Einschraenkung ist bei Verwendung von Class#GetResource[AsStream]() nicht gegeben. Aufgrund der vielen sich ergebenden Fallstricke ist ein Einlesen von Ressourcen ueber Class/Classloader in komplexeren Umgebungen nur sehr bedingt zu empfehlen. Bei Problemen damit oder mit dem Laden von Klassen ist es hilfreich, erst einmal die Struktur der CL-Hierarchie zu klaeren. 3.16.3 Wie lade ich eine Klasse neu? Autor: Ortwin Glück, Ulf Jaehrig, Patrick Roemer, Jan Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Im Wortsinn: Eigentlich gar nicht. Von 'guten' CLs wird gefordert, dass sie auf Anfragen nach demselben Klassennamen auch stets dasselbe Class-Exemplar liefern.[2] Wenn ein CL sich nicht daran hält, könnte es im System zwei Klassen geben, die per Definition identisch sind, aber eine ganz andere Struktur oder zumindest unterschiedliche Methodendefinitionen haben - ein sicheres Rezept für Ärger. Daher gilt seit Java 1.2: Eine Klasse kann nur entladen werden, wenn der zugehörige CL nicht mehr reachable und damit reif für den GC ist.[3] Demgemäss können Klassen, die durch den Bootstraploader geladen wurden, überhaupt nicht entladen werden. Vorsicht ist im Umgang mit älteren VMs geboten: In Java 1.0 gab es überhaupt kein Class-Unloading; in Java 1.1 konnten Klassen geradezu beliebig entladen werden, mit entsprechend verwirrenden Konsequenzen, z.B. bei Verwendung des Singleton-Patterns.[7] Wie erzeugt man nun trotz alldem den Effekt des 'Neuladens' von Klassen? Man lädt die geänderte Klassendefinition über einen neuen CL. Damit sind Exemplare der alten Klasse inkompatibel zu Exemplaren der neuen Version. Üblicherweise 'vergisst' man beim Neuladen den alten CL, so dass Exemplare der alten Klasse (so sie nicht anderweitig referenziert werden) fällig für den GC werden. Um dieses Auswechseln der Klasse für den Rest der Anwendung transparent zu halten, empfiehlt es sich, diese Klasse hinter einem Interface zu verstecken. Das Interface ist dem übergeordneten CL bekannt und Anfragen danach werden vom Reloading-CL an diesen delegiert, so dass überall in der Anwendung dasselbe Interface bekannt ist. Die 'änderbare' Klasse muss dieses Interface implementieren. Ihre Definition wird dann über einen Reloading-CL geladen und ein Exemplar erzeugt, das dem Rest der Applikation ausschliesslich als Ausprägung des Interface zur Verfügung gestellt wird. Ein Beispiel dieses Vorgehens findet sich in [4] und im Beispielcode. 3.16.4 Wie baue ich einen Plugin-Mechanismus? Autor: Ortwin Glück, Ulf Jaehrig, Patrick Roemer, Jan Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Unter einem Plugin-Mechanismus versteht man gemeinhin eine Möglichkeit, zur Compilezeit der Applikation noch unbekannte Klassen, die üblicherweise dasselbe Interface implementieren, zum Applikationsstart (oder irgendwann sonst zur Laufzeit) zu laden. Die Plugin-Klassen (oder entsprechende Jars/Unterverzeichnisse) liegen hierbei oft in einem besonderen Plugin-Verzeichnis, oder die Klassennamen und Positionen im Dateisystem werden der Applikation über eine Konfigurationsdatei mitgeteilt. Zum Applikationsstart werden die Klassen über einen eigenen CL (das kann ein selbstgeschriebener CL oder schlicht ein URLClassLoader[10] sein) geladen und dem Rest der Applikation als Exemplar des übergeordneten Interfacetyps bekanntgemacht. Beispiele für Plugin-Mechanismen findet man in IDEs, Servlet-Containern und Webbrowsern. Beim Entwickeln eines Plugin-Frameworks oder eines Plugins koennen einem schnell fiese CL-Probleme begegnen - [12] und [13] aus dem Eclipse-Wiki liefern etwas Anschauungsmaterial. 3.16.5 Gibt's dazu auch Beispielcode? Autor: Ortwin Glück, Ulf Jaehrig, Patrick Roemer, Jan Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // $HOME/player/PluginPlayer.java import java.io.*; import java.net.*; public class PluginPlayer { public static void main(String[] argv) { try { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); // Plugin-Verzeichnis setzen final File plugindir = new File(argv[0]).getCanonicalFile(); do { // Suche alle .class-Files im Plugin-Verzeichnis File[] pluginfiles = plugindir.listFiles( new FilenameFilter() { public boolean accept(File dir, String name) { return plugindir.equals(dir) && name.endsWith(".class") && name.indexOf("Plugin") > -1; } } ); // Erzeuge einen Loader fuer dieses Verzeichnis URLClassLoader loader = new URLClassLoader(new URL[]{plugindir.toURL()}); // Iteriere ueber alle .class-Files... System.out.println("Running plugins from: " + plugindir.toURL()); int numplugins = pluginfiles.length; for (int plugincnt = 0; plugincnt < numplugins; plugincnt++) { // ...extrahiere den Klassennamen... String filename = pluginfiles[plugincnt].getName(); String pluginname = filename.substring(0, filename.lastIndexOf(".")); System.out.println("Running plugin: " + pluginname); // ...lade die Klasse, erzeuge eine Instanz und caste... Plugin plugin = (Plugin) (loader.loadClass(pluginname).newInstance()); // ...setze den Context-Loader des ausfuehrenden Threads... Thread.currentThread().setContextClassLoader(loader); // ...rufe die entsprechende Methode auf... plugin.doIt(); // ...und setze den Context-Loader zurueck. ClassLoader parentloader = loader.getParent(); Thread.currentThread().setContextClassLoader(parentloader); } System.out.println("'q'[RET] to quit, [RET] to continue"); } while (!"q".equals(in.readLine())); } catch (Exception exc) { exc.printStackTrace(); } } } // $HOME/player/Plugin.java public interface Plugin { void doIt() throws Exception; } // $HOME/plugins/CLTestPlugin.java public class CLTestPlugin implements Plugin { // Laedt Klassen auf unterschiedliche Arten public void doIt() throws ClassNotFoundException { ClassLoader contextcl = Thread.currentThread().getContextClassLoader(); Class ac1 = contextcl.loadClass("AnotherClass"); Class ac2 = Class.forName("AnotherClass"); String firstresult = (ac1 == ac2 ? "fine" :"inconsistent"); System.out.println("Check #1: " + firstresult); ac1 = contextcl.loadClass("Plugin"); ac2 = AnotherClass.class.forName("Plugin"); Class ac3 = Plugin.class; String secondresult = (ac1 == ac2 && ac1 == ac3 ? "fine" :"inconsistent"); System.out.println("Check #2: " + secondresult); } } // $HOME/plugins/AnotherClass.java public class AnotherClass { } // $HOME/plugins/CLResourcePlugin.java import java.io.*; public class CLResourcePlugin implements Plugin { // Laedt einen Text als Ressource und gibt ihn aus public void doIt() throws IOException { InputStream instream = getClass().getResourceAsStream("msg.txt"); BufferedReader inreader = new BufferedReader(new InputStreamReader(instream)); String curline = null; while ((curline = inreader.readLine()) != null) { System.out.println(curline); } inreader.close(); } } // $HOME/plugins/msg.txt Hello, world! // $HOME/plugins/CLListPlugin.java public class CLListPlugin implements Plugin { // Listet alle beteiligten CL public void doIt() { ClassLoader contextcl= Thread.currentThread().getContextClassLoader(); System.out.println("Context CL: " + contextcl); ClassLoader curcl = getClass().getClassLoader(); while (curcl != null) { System.out.println(curcl); curcl = curcl.getParent(); } } } 3.16.6 ClassLoader Ressourcen zu 3.16.1 bis 3.16.5 Autor: Ortwin Glück, Ulf Jaehrig, Patrick Roemer, Jan Schulz ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [1] java.lang.ClassLoader API-Doc <URL:http://java.sun.com/j2se/1.4.1/docs/api/java/lang/ClassLoader.html> [2] JLS 12.2 <URL:http://java.sun.com/docs/books/jls/second_edition/html/ execution.doc.html#44459> [3] JLS 12.7 <URL:http://java.sun.com/docs/books/jls/second_edition/html/ execution.doc.html#74294> [4] JavaWorld-Artikel Classloader Java 1.0 Style <URL:http://www.javaworld.com/javaworld/jw-10-1996/jw-10-indepth.html> [5] JavaWorld-Artikel Classloader Java 1.1 Style <URL:http://www.javaworld.com/javaworld/jw-03-2000/jw-03-classload.html> [6] Sun-Tutorial Classloader Java 1.1 Style <URL:http://developer.java.sun.com/developer/onlineTraining/Security/ Fundamentals/magercises/ClassLoader/index.html> [7] JavaWorld-Artikel Classloader und Singletons <URL:http://www.javaworld.com/javatips/jw-javatip52_p.html> [8] JavaWorld-Artikel Typesafe Enumerations <URL:http://www.javaworld.com/javatips/jw-javatip122_p.html> [9] Tomcat Classloader-Howto <URL:http://jakarta.apache.org/tomcat/tomcat-4.1-doc/ class-loader-howto.html> [10] java.net.URLClassLoader API-Doc <URL:http://java.sun.com/j2se/1.4.1/docs/api/java/net/URLClassLoader.html> [11] SPI-Kapitel im Jar-Doc <URL:http://java.sun.com/j2se/1.4.1/docs/guide/jar/ jar.html#Service%20Provider> [12] Eclipse-Wiki Plugin-Development <URL:http://eclipsewiki.swiki.net/114> [13] Eclipse-Wiki Classloader Tricks <URL:http://eclipsewiki.swiki.net/123> 4. Bücher zum Thema Java ======================== 4.1. Kann mir jemand gute Literatur zum Thema Java empfehlen? ------------------------------------------------------------- <URL:http://www.dclj.de/links.html> bietet eine kleine Übersicht über Bücher, die zum freien Download zur Verfügung stehen. Weiterhin bietet die Seite <URL:http://www.accu.org/bookreviews> viele aufschlussreiche Besprechungen von Java-Büchern. Hier nochmal in aller Kürze: * The Java Tutorial - <URL:http://java.sun.com/docs/books/tutorial/> * Java ist auch eine Insel - <URL:http://www.java-tutor.com/> * Go To Java 2 - <URL:http://www.javabuch.de/> * Thinking in Java - <URL:http://www.mindview.net/Books/TIJ/> In Buchform sind die folgenden Werke interessant: * Go To Java 2 - Handbuch der Java-Programmierung Guido Krüger Addison-Wesley ISBN: 382731710X 15. September 2000 1224 Seiten <URL:http://www.javabuch.de/> - Eines der Standardwerke für angehende Javaprogrammierer und Kaffetrinker. Zumindest als Onlineversion sollte es sich jeder mal angeschaut haben, denn es bietet einen umfassenden und dennoch nicht zu sehr ins Detail gehenden Überblick ueber die verschiedenen Komponenten der Sprache Java. * Java ist auch eine Insel - Programmieren für die Java 2-Plattform in der Version 1.4 Christian Ullenboom Galileo Press ISBN: 3898421740 Dezember 2001 1239 Seiten <URL:http://www.java-tutor.com/javabuch/download.htm> * Java. Programmierhandbuch und Referenz für die Java-2-Plattform - Einführung und Kernpakete. Mit CD-ROM. Stefan Middendorf, Reiner Singer dpunkt-Verlag, Heidelberg ISBN 3920993829 1999 1256 Seiten * Java2 Designmuster und Zertifizierungswissen Friedrich Esser Galileo Press ISBN 3934358667 2001 654 Seiten * Einführung in die objektorientierte Programmierung mit Java Ernst-Erich Doberkat, Stefan Dißmann Oldenbourg ISBN 3486247867 2000 315 Seiten * Java Gently Judy M. Bishop Addison-Wesley ISBN 0201342979 1998 508 Seiten * Die Java2 Fibel Ralf Künel Addison-Welsey ISBN 3827314100 1999 442 Seiten * Datenbanken und Java. JDBC, SQLJ und ODMG Gunter Saake, Kai-Uwe Sattler dpunkt-Verlag, Heidelberg 2000 ISBN: 3932588541 * Java Servlet Programming Jason Hunter, William Crawford O'Reilly ISBN 156592391X 1988 510 Seiten * Komponenten in Java: Einsatz und Entwicklung von JavaBeans mit VisualAge for Java Claudia Piemont dpunkt-Verlag ISBN 3932588215 1999 347 Seiten * Design mit Java. Bessere Applets und Anwendungen Peter Coad, Mark Mayfield Markt und Technik ISBN: 3827295866 1999 301 Seiten englischsprachig, aber auch gut: * Effective Java, Programming Language Guide Joshua Bloch The Java Series Addison-Wesley ISBN 0201310058 * Image Processing in Java Douglas A. Lyon Prentice Hall ISBN 0-13-97457707 1999 532 Seiten 5. Themenverwandte Internet Ressourcen ====================================== 5.1. WWW-Sites -------------- Deutschsprachige: Java: + Immer aktuelle archivierte Version dieser Text FAQ <URL:ftp://rtfm.mit.edu/pub/usenet-by-group/ de.answers/de/comp-lang-java/faq> + HTML Version dieser FAQ von Uwe Plonus <URL:http://de.geocities.com/uweplonus/faq/> + deutsche Java-FAQ von Markus Reitz (de.comp.lang.java) <URL:http://www.dclj.de/> <URL:http://www.geocities.com/SiliconValley/Foothills/5270/> + Java-Einfuehrung von Hubert Partl (BOKU Wien) <URL:http://www.boku.ac.at/javaeinf/> + Go to Java 2 von Guido Krueger (Addison Wesley Verlag) <URL:http://www.javabuch.de/> <URL:http://www.gkrueger.com/> + Java ist auch eine Insel von Christian Ullenboom <URL:http://java-tutor.com/> + Java Dokumentation von Brit Schroeter und Johann Plank <URL:http://www.selfjava.de/> + Liste weiterer Links, zusammengestellt von Ralf Geschke (Uni Koeln) <URL:http://infosoc.uni-koeln.de/akademie/java/> HTML, XHTML: <URL:http://www.teamone.de/selfhtml/> <URL:http://www.boku.ac.at/htmleinf/> <URL:http://art2.ph-freiburg.de/HTML-Tutor/> <URL:http://www.netandmore.de/faq/> XML: <URL:http://www.mintert.com/xml/> <URL:http://www.boku.ac.at/htmleinf/xmlkurz.html> WAP und WML: <URL:http://www.boku.ac.at/htmleinf/wein.html> <URL:http://allnetdevices.com/faq/> Englischsprachige: Java: + Java Online-Doku der Firma Sun <URL:http://java.sun.com/docs/> + Java Tutorial der Firma Sun <URL:http://java.sun.com/docs/books/tutorial/index.html> + Java FAQ von Eliotte Rusty Harold <URL:http://sunsite.unc.edu/javafaq/javafaq.html> + Java Programmers FAQ von Peter van der Linden <URL:http://www.afu.com/javafaq.html> + Java Glossary von Roedy Green <URL:http://mindprod.com/gloss.html> + Thinking in Java von Bruce Eckel <URL:http://www.BruceEckel.com/javabook.html> + Java Tutorial von Prof. Baldwin <URL:http://www.phrantic.com/scoop/toc.htm> + Swing FAQ von Linda Radecke <URL:http://www.jalice.net/textfaq.htm> <URL:http://www.jalice.net/tablefaq.htm> <URL:http://www.jalice.net/componentfaq.htm> + Tips zu Java von Marco Schmidt <URL:http://jiu.sourceforge.net/javatips.html> HTML, XML, XHTML u.a.: <URL:http://www.w3.org/> WAP, WML: <URL:http://www.wapforum.org/> Anmerkung: Diese Liste ist meine subjektive Auswahl und stellt keinen Anspruch auf Vollstaendigkeit oder Objektivitaet. 5.2. Newsgroups --------------- <news:comp.lang.java.3d> <news:comp.lang.java.advocacy> <news:comp.lang.java.beans> <news:comp.lang.java.corba> <news:comp.lang.java.databases> <news:comp.lang.java.gui> <news:comp.lang.java.help> <news:comp.lang.java.machine> <news:comp.lang.java.programmer> <news:comp.lang.java.security> <news:comp.lang.java.softwaretools> 5.3. Mailinglisten ------------------ <mailto:java-linux@java.blackdown.org> <mailto:nbusers@netbeans.org> 6. JavaScript Internet Ressourcen. ================================== 6.1 WWW-Sites <URL:http://www.teamone.de/selfhtml/> <URL:http://www.dcljs.de/> 6.2. Newsgroups <news:de.comp.lang.javascript> 7. Credits ========== Folgende Personen waren an der Erstellung der FAQ beteiligt: Werner Baumann, Gerhard Bloch, Frank Buss, Paul Ebermann, Alexander Elsholz, Martin Erren, Uwe Günther, Erwin Hoffmann, Ingo R. Homann, Ulf Jährig, Christian Kaufhold, Georg Lipitsch, Peter Luschny, Stephan Menzel, Alexander Merkelbach, Michael Paap, Hubert Partl, Achim Peters, Uwe Plonus, Sascha Raabe, Markus Reitz, Aljoscha Rittner, Wolfram Rühaak, Joachim Sauer, Wolfgang Schirmer, Marco Schmidt, Michael Schmidt, Karsten Schulz, Roger Schuster, Jochen Theodorou, Tobias Vogele, Christian Wederhake (in alphabetischer Reihenfolge). Die Version 1.0 dieser FAQ baut auf den FAQs von Hubert Partl, Markus Reitz und Michael Schmidt auf. Kritik und Verbesserungsvorschläge an der FAQ bitte direkt an den Autor oder in die Newsgroup mit dem Tag [FAQ] im Subject. User Contributions:
[ Usenet FAQs | Web FAQs | Documents | RFC Index ]
Send corrections/additions to the FAQ Maintainer: uwe@cscc.de (Uwe Guenther)
Last Update March 27 2014 @ 02:11 PM
|
FAQ der Newsgroup de.comp.lang.java Version 1.44 vom 07.10.2005
Search the FAQ Archives
N - O - P - Q - R - S - T - U - V - W - X - Y - Z
FAQ der Newsgroup de.comp.lang.java Version 1.44 vom 07.10.2005
[ Usenet FAQs | Web FAQs | Documents | RFC Index | Cities ]
Comment about this article, ask questions, or add new information about this topic: