From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../hjp5/html/k100019.html | 377 +++++++++++++++++++++ 1 file changed, 377 insertions(+) create mode 100644 Master/Reference Architectures and Patterns/hjp5/html/k100019.html (limited to 'Master/Reference Architectures and Patterns/hjp5/html/k100019.html') diff --git a/Master/Reference Architectures and Patterns/hjp5/html/k100019.html b/Master/Reference Architectures and Patterns/hjp5/html/k100019.html new file mode 100644 index 0000000..820eee8 --- /dev/null +++ b/Master/Reference Architectures and Patterns/hjp5/html/k100019.html @@ -0,0 +1,377 @@ + + + +Handbuch der Java-Programmierung, 5. Auflage + + + + + + + + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage +
 <<  +  <   +  >   + >>  + API  +Kapitel 3 - Wie geht es weiter? +
+
+ + + + +

3.1 Wie sollte man dieses Buch lesen?

+
+ +
+ + + + +

3.1.1 Zu welchem Typ Leser gehören Sie?

+ +

+Sie haben nun einen ersten Eindruck von Java gewonnen und wollen Ihr +Wissen vervollständigen. Natürlich können Sie das Buch +einfach Seite für Seite weiterlesen und dabei die Sprache Java +und den Umgang mit ihrer umfassenden Klassenbibliothek erlernen. Vielleicht +wollen Sie aber gar nicht bis Kapitel 39 +warten, um zu erfahren, wie man ein Applet schreibt? Vermutlich wollen +Sie auch nicht bis Kapitel 51 +warten, um den Umgang mit dem Debugger kennenzulernen? Auch kann es +sein, dass Sie nicht an der Dateiein-/-ausgabe interessiert sind und +die Kapitel 18, +19 und 20 +daher zunächst überspringen wollen. Je nach Ihren Vorkenntnissen +und Absichten wird eine ganz bestimmte Vorgehensweise sinnvoll sein. +Wir wollen in den nächsten Abschnitten ein paar Tipps zum Lesen +des Buchs und einige Hinweise zum Inhalt der einzelnen Kapitel geben. + +

+Falls Sie zu dem Leserkreis gehören, der bereits einige Erfahrungen +mit der Entwicklung von Programmen in einer konventionellen Hochsprache +wie Pascal oder C hat, und Sie dieses Buch vor allem lesen, um auf +den Java-Zug aufzuspringen, sind Sie hier goldrichtig. Lesen Sie das +Buch einfach von vorne nach hinten und lernen Sie in jedem Kapitel +ein wenig dazu. Einige Dinge - insbesondere in den vorderen Kapiteln +- werden Ihnen vertraut vorkommen. Aber bereits ab Kapitel 7 +werden Sie mit vielen Neuigkeiten konfrontiert, die den Reiz der Sprache +ausmachen. Lesen Sie das Buch in aller Ruhe, nehmen Sie sich Zeit, +die Beispiele nachzuvollziehen, und machen Sie eigene Experimente. +Einige der Kapitel behandeln Spezialthemen, die nicht von jedem benötigt +werden, und können beim ersten Lesen übersprungen werden. +Sie werden am Ende des Buchs ein sicheres Verständnis für +alle grundlegenden Belange der Java-Programmierung haben und können +sich leicht in komplexere Themengebiete einarbeiten. + +

+Falls Sie bereits weitreichende Programmiererfahrung in einer objektorientierten +Sprache wie C++ oder SmallTalk haben, werden Sie sich am Anfang unterfordert +fühlen. Die in Kapitel 4 +bis Kapitel 6 eingeführten +Grundlagen kommen Ihnen bekannt vor, die ab Kapitel 7 +behandelte objektorientierte Programmierung kennen Sie im Schlaf, +und die in Kapitel 13 +vorgestellten Techniken zur Entwicklung größerer Programme +sind ebenfalls nichts Neues für Sie. Aber kennen Sie sich auch +mit Multithreading, Kryptographie, dem Abstract Windowing Toolkit +und den Java Foundation Classes aus? Wissen Sie, wie grafische Animationen +entwickelt werden, wie man Objekte im Netz verteilt oder auf SQL-Datenbanken +zugreift? Kennen Sie Java-Konzepte wie Serialisierung, Reflection +oder Beans? Wenn nicht, dann werden auch Sie in diesem Buch interessante +und wissenswerte Neuigkeiten finden. + +

+Falls Sie zu dem Leserkreis gehören, der hauptsächlich Applets +entwickeln will, verspüren Sie wahrscheinlich keine Lust, viele +Kapitel darauf zu warten, das erste Applet vorgesetzt zu bekommen. +Natürlich müssen Sie die Grundlagen der Sprache kennen, +um Applets entwickeln zu können. Es spricht aber nichts dagegen, +dass Sie sich bereits während der Lektüre der Grafikgrundlagen +in den Kapiteln 23 +bis 29 mit der Applet-Programmierung, +die in Kapitel 39 und 40 +beschrieben wird, vertraut machen. Die Unterschiede zwischen Applikationen +und Applets halten sich in Grenzen, und sie werden genau erklärt. + +

+Auch wenn Sie zu dem Typ Leser gehören, der Bücher nie am +Stück liest, sondern nur dann zur Hand nimmt, wenn er nach einer +Lösung für ein spezielles Problem sucht, kann dieses Buch +für Sie nützlich sein. Die Gliederung erleichtert auch das +Wiederfinden spezieller Themen. Verwenden Sie einfach das Inhaltsverzeichnis +oder den umfassenden Index, um das Thema zu finden, an dem Sie gerade +besonders interessiert sind. Zögern Sie nicht, die Beispielprogramme +in die Tat umzusetzen und eigene Experimente durchzuführen. Es +gibt viele Leser, die auf diese Weise am besten lernen. + +

+Wenn Sie dagegen überhaupt keine Programmiererfahrung haben, +wird die Lektüre des Buchs nicht einfach werden. An vielen Stellen +werden Grundkenntnisse in Datenstrukturen, Algorithmen und der Entwicklung +von Computerprogrammen vorausgesetzt. Die Kapitel mit den fortgeschrittenen +Themen setzen darüber hinaus ein gutes Verständnis der einführenden +Kapitel voraus. Sollten Ihnen diese Kenntnisse fehlen, versuchen Sie +unbedingt, sie sich anzueignen. In Abschnitt 3.2 +finden Sie Hinweise auf weiterführende Dokumentationen und Online-Ressourcen, +die Ihnen dabei helfen können. +

+ + + + + + + + + + + +
+ +

+Einigen Zuschriften entnahm ich, dass es den Lesern mitunter an elementaren +Grundkenntnissen im Umgang mit dem Computer und seinem Betriebssystem +mangelt. Die Leser dieser Gruppe sind dann gleich zu Beginn frustriert, +weil etwa die Installation des JDK nicht klappt, der PATH nicht gesetzt +wurde oder sie noch nie einen Editor gesehen haben. Falls Sie zu dieser +Gruppe gehören, sollten Sie sich das fehlende Wissen unbedingt +aneignen, sonst sind Misserfolgserlebnisse vorprogrammiert. In Abschnitt 2.3.7 +werden einige Hinweise zu diesen elementaren Themen gegeben, aber +ausreichend ist das nur, wenn schon gewisse Grundkenntnisse vorhanden +sind.

 + + + + +
 Warnung 
+
+

+ + + + + + + + + +
+ +

+Dieses Buch enthält an vielen Stellen Vorwärtsverweise auf +Themen, die noch nicht behandelt wurden. Dadurch wird den Verflechtungen +innerhalb der Themenbereiche Rechnung getragen, und man findet beim +Nachschlagen schnell alle relevanten Textstellen. Wenn Sie beim Lesen +auf einen Vorwärtsverweis stoßen, können Sie normalerweise +zunächst warten, bis die Erklärung nachgereicht wird (oftmals +schon kurze Zeit später). Sie können den Begriff natürlich +auch sofort nachschlagen, aber aus didaktischen Gründen ist das +meist nicht unbedingt notwendig.

 + + + + +
 Hinweis 
+
+ + + + +

3.1.2 Was ist der Inhalt der einzelnen Kapitel?

+ +

+Die Kapitel 1 und 2 +haben Sie bereits gelesen, Sie kennen also die wichtigsten Schlagworte +zu Java und haben ein lauffähiges Entwicklungssystem. In diesem +Kapitel erhalten Sie Informationen zum Inhalt des Buchs und bekommen +Tipps, wie Sie es am besten verwenden können. Auch Hinweise auf +weiterführende Informationen finden Sie hier. + +

+Die Kapitel 4, 5 +und 6 beschäftigen +sich mit den elementaren Eigenschaften der Sprache. Sie erklären +die lexikalische Struktur von Java-Programmen und stellen Datentypen, +Ausdrücke und Anweisungen vor. Wenn Sie bereits mit C oder C++ +vertraut sind, werden Ihnen viele Dinge bekannt vorkommen. Dennoch +gibt es einige elementare, aber wichtige Unterschiede, und auch als +erfahrener C/C++-Programmierer sollten Sie nicht vollständig +auf die Lektüre dieser Kapitel verzichten. + +

+Kapitel 7 erklärt wichtige +Grundlagen der objektorientierten Programmierung und erläutert +Klassen und Objekte in Java. Auch die Definition und Verwendung von +Methoden werden in diesem Kapitel behandelt. Kapitel 8 +ist ebenfalls essentiell. Es beschreibt die Prinzipien der Vererbung, +erläutert Attribute von Klassen und erklärt statische Membervariablen +und Methoden. Schließlich werden abstrakte Klassen und Polymorphismus +behandelt. Zu den wichtigsten Techniken der objektorientierten Programmierung +in Java gehören Interfaces, die in Kapitel 9 +beschrieben werden. Mit der Vorstellung einiger weiterführender +Themen bildet Kapitel 10 den +Abschluss der objektorientierten Programmierung. Während lokale +und anonyme Klassen ebenso wie Wrapper-Klassen zum Handwerkszeug jedes +Java-Programmierers gehören sollten, ist der ausführliche +Teil über Design-Patterns optional und kann beim ersten Lesen +ausgelassen werden. + +

+Im nächsten Teil des Buchs werden weiterführende Spracheigenschaften +und Grundlagen der Klassenbibliothek behandelt. Die Kapitel 11 +bis 17 sind ebenso wichtig +wie die Grundlagen der Sprache. Sie behandeln Strings, Exceptions +und Packages, erklären die Collections und stellen die wichtigsten +Utility-Klassen vor. Einzig Kapitel 15 +könnte beim ersten Lesen übersprungen werden, denn dort +wird das mit dem JDK 1.2 eingeführte Collection-API vorgestellt. +Die seit der Version 1.0 vorhandenen Collections sind dagegen Pflicht +und werden in Kapitel 14 +behandelt. Die nächsten vier Kapitel 18 +bis 21 beschäftigen +sich mit Dateizugriffen. Sie erläutern zeichen- und byteorientierte +Streams, Random-Access-Dateien und den Zugriff auf Verzeichnisse. +Den Abschluss des vierten Teils bildet Kapitel 22 +mit der Behandlung des Multithreadings. + +

+Die darauffolgenden Kapitel beschäftigen sich mit dem Abstract +Windowing Toolkit und zeigen, wie man Java-Programme mit grafischer +Oberfläche schreibt. Während Kapitel 23 +bis 29 Grundlagen +behandelt, die auch dann wichtig sind, wenn nur Swing-Programme geschrieben +werden sollen, werden in den Kapiteln 30 +und 32 ausschließlich +AWT-Menüs und -Dialogelemente vorgestellt. Kapitel 31 +erklärt den Umgang mit Layoutmanagern und ist sowohl für +AWT- als auch für Swing-Programme wichtig. Den Abschluss dieses +Teils bilden zwei Kapitel, in denen gezeigt wird, wie eigene Dialogelemente +entwickelt werden können und wie man Bitmaps und Animationen +einsetzt. Zwar sind sie weitgehend AWT-spezifisch, doch ist ihr Inhalt +auch für entsprechende Swing-Programme und zum Verständnis +der Java-Beans-Architektur vonnöten. + +

+Teil 6 des Buchs befasst sich mit der Programmierung von grafischen +Oberflächen mit Swing. Während in Kapitel 35 +Grundlagen erklärt und Unterschiede bzw. Parallelen zum AWT aufgezeigt +werden, behandeln die nächsten drei Kapitel alle wichtigen Dialogelemente +des Swing-Toolkits. Zusammen mit den im vorigen Teil vermittelten +Grundlagen stehen nach Ende dieses Teils ausreichend Kenntnisse zur +Entwicklung eigener Swing-Applikationen zur Verfügung. + +

+In den nachfolgenden Kapiteln 39 +und 40 wird die Applet-Programmierung +erläutert. Diese Kapitel können bei Bedarf auch vorgezogen +werden, insbesondere Swing-Kenntnisse sind zu ihrem Verständnis +nicht nötig. Die Grundlagen der Grafikprogrammierung aus Kapitel +5 sollten Sie allerdings gelesen haben. + +

+Die beiden letzten Teile des Buchs behandeln eine Reihe weiterführender +Themen. Die Kapitel 41 +und 42 erweitern die Möglichkeiten, +Daten persistent zu speichern. Sie erläutern das Serialisieren +von Objekten und beschreiben den Zugriff auf relationale Datenbanken. +In Kapitel 43 wird gezeigt, +wie mit Hilfe des Reflection-APIs zur Laufzeit auf die Interna von +Klassen und Objekten zugegriffen werden kann und wie Sie mit Hilfe +von Annotationen Zusatzinformationen in Ihre Klassen integrieren. +In Kapitel 44 wird die zum +Erstellen eigenständiger Komponenten wichtige Java-Beans-Architektur +vorgestellt. + +

+Die nächsten beiden Kapitel 46 +und 47 beschäftigen sich +mit der Netzwerkprogrammierung. Während das Erste die Grundlagen +vorstellt und zeigt, wie TCP/IP-Clients und -Server geschrieben werden, +stellt das Zweite verteilte Objektarchitekturen mit RMI vor. Den Abschluss +dieses Teils bildet Kapitel 48 +mit der Vorstellung des Sicherheitskonzepts von Java und der Beschreibung +signierter Applets. Hier werden auch wichtige kryptografische Grundlagen +erläutert. In Kapitel 49 +wird das Sound-API vorgestellt, und in den letzten beiden Kapiteln +des Buchs werden Hinweise zur Steigerung der Performance von Java-Programmen +und zum Umgang mit den Hilfsprogrammen des JDK gegeben. + + + + +

3.1.3 Wie geht es nun weiter?

+ +

+Daß man Bücher unterschiedlich gliedern kann, ist kein +Geheimnis. Daß die Beschreibung einer Programmiersprache mehr +Aufwand erfordert als die eines Mobiltelefons oder Videorecorders, +ist ebenfalls bekannt. Ist es nun besser, eine umfangreiche Programmiersprache +zunächst aus der Vogelperspektive zu betrachten und nur die jeweils +benötigten Themen rezeptartig nachzuschlagen? Um so mit geringstem +Mitteleinsatz frühzeitig lauffähige (aber nicht notwendigerweise +verstandene) Ergebnisse zu produzieren? Oder sollte man zunächst +die Grundlagen der Sprache studieren und erst später die komplexeren +Hilfsmittel auf der Basis eines soliden Grundlagenwissens einsetzen? + +

+Wie die Kapitelaufteilung zeigt, wurde dieses Buch unter der Annahme +geschrieben, dass der zweite Ansatz der sinnvollere ist. Platt ausgedrückt, +stehen die einfachen Dinge weiter vorne und die schwierigen weiter +hinten, und im Zweifelsfall ist diese Leserichtung durchaus sinnvoll. +Das soll allerdings keinesfalls heißen, dass unter allen Umständen +und für alle Leser das sequenzielle Durchlesen die richtige Vorgehensweise +ist. Wie erwähnt, mag es durchaus sinnvoll sein, zu einem anderen +Ablauf zu kommen. Gerade beim Einsatz im geschäftlichen Umfeld +hat man durch Termin- und Projektdruck nicht immer die Zeit, die Anwendung +neuer Werkzeuge mit der nötigen Ruhe zu erlernen. + +

+Letztendlich müssen Sie selbst entscheiden, welche der Kapitel +Sie durchlesen wollen und in welcher Reihenfolge Sie das tun. Die +vorgegebene Kapitelaufteilung und -reihenfolge mag Ihnen dabei ein +Leitfaden sein. Wählen Sie die Technik, die Ihren Neigungen und +Erwartungen am meisten entgegenkommt und am besten mit Ihren Beweggründen +in Einklang zu bringen ist. Dann werden Sie den größtmöglichen +Nutzen aus dem Buch ziehen. +

+ + + +
 Titel  + Inhalt  + Suchen  + Index  + DOC  +Handbuch der Java-Programmierung, 5. Auflage, Addison +Wesley, Version 5.0.1 +
 <<  +  <   +  >   + >>  + API  +© 1998, 2007 Guido Krüger & Thomas +Stark, http://www.javabuch.de +
+ + + -- cgit v1.2.3