Java als erste Programmiersprache

Cornelia Heinisch, Frank Müller-Hofmann,
Joachim Goll
Java als erste
Programmiersprache
Cornelia Heinisch, Frank Müller-Hofmann,
Joachim Goll
Java als erste
Programmiersprache
Vom Einsteiger zum Profi
5., überarbeitete und erweiterte Auflage
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der
Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über
<http://dnb.d-nb.de> abrufbar.
Dr. Cornelia Heinisch, geb. Weiß, Jahrgang 1976, studierte Softwaretechnik an der
Hochschule Esslingen. Seit ihrem Diplom im Jahre 1999 ist sie Lehrbeauftragte für
Objektorientierte Modellierung an der Hochschule Esslingen. Cornelia Heinisch
arbeitet bei der Firma IT-Designers GmbH als System-Designerin für Verteilte Objektorientierte Systeme.
Frank Müller-Hofmann, MSc, Jahrgang 1969, studierte Softwaretechnik an der
Hochschule Esslingen nach Lehre und Beruf. Herr Müller-Hofmann arbeitet als
System-Designer für Verteilte Objektorientierte Systeme bei IT-Designers. Er ist Lehrbeauftragter für Internettechnologien an der Hochschule Esslingen und für Kommunikation in Verteilten Systemen an der Brunel University of West-London.
Prof. Dr. Joachim Goll, Jahrgang 1947, unterrichtet seit 1991 im Fachbereich
Informationstechnik der Hochschule Esslingen Programmiersprachen, Betriebssysteme,
Software Engineering, Objektorientierte Modellierung und Sichere Systeme.
Während seiner beruflichen Tätigkeit in der Industrie befasste er sich vor allem mit
dem Entwurf von Verteilten Informationssystemen. Prof. Goll ist Leiter des SteinbeisTransferzentrums Softwaretechnik Esslingen.
1. Auflage 2000
5., überarbeitete und erweiterte Auflage März 2007
Alle Rechte vorbehalten
© B. G. Teubner Verlag / GWV Fachverlage GmbH, Wiesbaden 2007
Lektorat: Ulrich Sandten / Kerstin Hoffmann
Der B. G. Teubner Verlag ist ein Unternehmen von Springer Science+Business Media.
www.teubner.de
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung
des Verlags unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen,
Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in
elektronischen Systemen.
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk
berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne
der Waren- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann
benutzt werden dürften.
Umschlaggestaltung: Ulrike Weigel, www.CorporateDesignGroup.de
Druck und buchbinderische Verarbeitung: Strauss Offsetdruck, Mörlenbach
Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier.
Printed in Germany
ISBN 978-3-8351-0147-0
Vorwort
Die Sprache Java ist durch ihre Betriebssystem-Unabhängigkeit ideal für die Realisierung verteilter Systeme, die aus verschiedenartigsten Rechnern vom Handy bis
zum Großrechner aufgebaut sein können. Java wird heute bereits im InformatikUnterricht an den Gymnasien unterrichtet und ist fester Bestandteil des Studiums von
Ingenieuren und Betriebswirten geworden.
Java stellt im Grunde genommen eine einfache Sprache dar. Darüber hinaus werden
jedoch in umfangreichen Klassenbibliotheken wertvolle und weitreichende Hilfsmittel
zur Verfügung gestellt, die den Bau verteilter Systeme mit Parallelität, Oberflächen,
Kommunikationsprotokollen und Datenbanken in erheblichem Maße unterstützen.
Dieses Buch wendet sich an Studierende, Umsteiger und Schüler, welche das
Interesse haben, die Grundlagen von Java fundiert zu erlernen. Es erlaubt, Java
ohne Vorkenntnisse anderer Programmiersprachen zu erlernen. Daher der Titel
„Java als erste Programmiersprache“. Dazu ist aber erforderlich, dass die
Übungsaufgaben am Ende eines Kapitels bearbeitet werden. Wer das Buch nur
lesen möchte, sollte bereits über die Kenntnisse einer anderen Programmiersprache
verfügen.
Dieses Buch hat das ehrgeizige Ziel, dem Neuling die Sprachkonzepte von Java, die
Grundkonzepte der objektorientierten Programmierung und wichtige Teile der
Klassenbibliothek so präzise wie möglich und dennoch in leicht verständlicher Weise
vorzustellen. Aber unterschätzen Sie dennoch den Lernaufwand nicht. Der Buchumfang ist nicht in einer einzigen Vorlesung zu schaffen. Vorlesungen über das
Programmieren verteilter Systeme mit Java oder über Grafische Oberflächen mit
Java machen erst dann Sinn, wenn die Grundlagen des Programmierens erlernt sind.
Die Kapitel 1 bis einschließlich 21 enthalten Übungsaufgaben, die zum selbstständigen Programmieren herausfordern. Dasselbe Ziel hat das Flughafen-Projekt, welches begleitend zu den einzelnen Kapiteln durchgeführt werden kann und zu einem
System führt, das die Fluglotsen bei Start und Landung von Flugzeugen unterstützt.
Unser besonderer Dank bei dieser Auflage gilt Herrn Mathias Altmeyer, der in
monatelanger Arbeit viele Kapitel wesentlich überarbeitet hat. Herrn Daniel Frank
danken wir für die Überarbeitung der Kapitels Servlets und JavaServer Pages, Herrn
Daniel Förster für die Erstellung der Anhänge Annotations und JNDI und Herrn
Marco Hentschel für Rat und Tat beim Kapitel Swing. Herr Carsten Timm und Herr
Norman Walter waren uns bei der Erstellung von Bildern und der CD eine große
Hilfe.
Esslingen, im Februar 2007
C. Heinisch / F. Müller-Hofmann / J. Goll
Wegweiser durch das Buch
„Lernkästchen“, auf die grafisch durch eine kleine Glühlampe aufmerksam gemacht
wird, stellen eine Zusammenfassung eines Kapitels dar. Sie erlauben eine rasche
Wiederholung des Stoffes.
Gerade als Anfänger in einer Programmiersprache macht man gerne den Fehler,
sich beim Lesen an nicht ganz so wesentlichen Einzelheiten festzubeißen. Um zu
erkennen, welche Information grundlegend für das weitere Vorankommen ist und
welche Information nur ein Detailwissen darstellt – und deshalb auch noch zu einem
späteren Zeitpunkt vertieft werden kann – weist dieses Buch Kapitel oder Kapitelteile,
die beim ersten Lesen übersprungen werden können, mit dem Symbol aus.
Generell ist es empfehlenswert, ein oder mehrere Kapitel zu überfliegen, um sich
einen Überblick zu verschaffen, und dann erst mit der Feinarbeit zu beginnen und
gründlicher zu lesen. Dennoch gilt: Eine Vorgehensweise, die sich für den einen
Leser als optimal erweist, muss noch lange nicht für alle Leser das Allheilmittel
darstellen. Wenn Sie zu den Lesern gehören, die es gewohnt sind, von Anfang an
möglichst detailliert zu lesen, um möglichst viel sofort zu verstehen, so sollten Sie
zumindest darauf achten, dass Sie in den Kapiteln mit dem „Überspringe und komm
zurück“-Zeichen beim ersten Durchgang nicht zu lange verweilen.
Bei all den guten Ratschlägen gilt: Programmieren hat man zu allen Zeiten durch
Programmierversuche erlernt. „Do it yourself“ heißt der rote Faden zum Erfolg. So
wie ein Kleinkind beim Erlernen der Muttersprache einfach zu sprechen versucht, so
sollten auch Sie möglichst früh versuchen, in der Programmiersprache zu sprechen –
das heißt, eigene Programme zu schreiben. Gestalten Sie den Lernvorgang abwechslungsreich – lesen Sie einen Teil und versuchen Sie, das Erlernte im
Programmieren gleich umzusetzen. Um die mühsame Tipparbeit am Anfang minimal
zu halten, sind alle Beispielprogramme des Buches auf der CD zu finden. Die CD
enthält auch die Bilder der einzelnen Kapitel, die Übungsaufgaben und Lösungen
sowie das Flughafenprojekt.
Die nachfolgende Tabelle soll es dem Leser erleichtern, einzuordnen, welche Kapitel
zu den Grundlagen (Symbol ) zählen und auf jeden Fall verstanden werden sollten,
welche Kapitel zuerst übersprungen werden können und dann bei Bedarf gelesen
), und welche Kapitel rein fortgeschrittene Themen
werden sollten (Symbol
(Symbol ) behandeln, die unabhängig voneinander gelesen werden können.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Grundbegriffe der Programmierung
Objektorientierte Konzepte
Einführung in die Programmiersprache Java
Einfache Beispielprogramme
Lexikalische Konventionen
Datentypen und Variablen
Ausdrücke und Operatoren
Kontrollstrukturen
Blöcke und Methoden
Klassen und Objekte
Vererbung und Polymorphie
Pakete
Ausnahmebehandlung
Schnittstellen
Geschachtelte Klassen
Ein-/Ausgabe und Streams
Generizität
Collections
Threads
Applets
Oberflächenprogrammierung mit Swing
Servlets
JavaServer Pages
Sockets
Remote Method Invocation
JDBC
Enterprise JavaBeans 3.0
Die folgende Tabelle zeigt die auf der CD enthaltenen Kapitel:
28
29
30
31
32
33
Java Native Interface
Sicherheit
Beans
Reflection
Java-Tools
Java Management Extensions
Schreibweise
In diesem Buch sind der Quellcode und die Ein-/Ausgabe von ganzen Beispielprogrammen sowie einzelne Anweisungen und Ein-/Ausgaben in der Schriftart
Courier New geschrieben. Dasselbe gilt für Programmteile wie Variablennamen,
Methodennamen etc., die im normalen Text erwähnt werden. Wichtige Begriffe im
normalen Text sind fett gedruckt, um sie hervorzuheben.
Ihre Verbesserungsvorschläge und kritischen Hinweise, die wir gerne annehmen,
erreichen uns via E-Mail:
[email protected]
Ihr Partner für
IT-Entwicklungen
Auf der Basis langjähriger Projekterfahrungen
in der Konzeption und Realisierung von
IT-Systemen sind wir besonders auf folgende
Leistungen spezialisiert:
쮿
Konzeption, Entwurf, Implementierung
sowie Integration und Test von
- Informationssystemen
- eingebetteten Systemen
- mobilen Systemen
und deren Kombination
쮿
Betrieb von Web-Applikationen
zur Unterstützung verteilter
Entwicklungsprozesse
쮿
Einsatz geeigneter Vorgehensmodelle,
Methoden und Tools
쮿
Durchführung von Schulungen in
- Software Engineering
- Programmiersprachen
Der ständige Wissenstransfer unserer hoch
qualifizierten Systemarchitekten zu Industriekunden und Hochschulen ermöglicht die
Verwendung aktueller Entwicklungstechniken.
Wir entwickeln für Sie ausbaufähige
maßgeschneiderte IT-Lösungen.
Ihre Aufgabe – unsere Herausforderung.
IT-Designers GmbH
Entennest 2 · 73730 Esslingen
Tel. 0711 / 30 51 11- 50 · Fax 0711 / 30 51 11-12
E-Mail: [email protected] · www.it-designers.de
Inhaltsverzeichnis
1 GRUNDBEGRIFFE DER PROGRAMMIERUNG ................................ 2
1.1
1.2
1.3
1.4
1.5
1.6
1.7
Das erste Programm................................................................................. 2
Vom Problem zum Programm .................................................................. 4
Nassi-Shneiderman-Diagramme ............................................................ 10
Zeichen ................................................................................................... 16
Variablen................................................................................................. 18
Datentypen ............................................................................................. 19
Übungen ................................................................................................. 25
2 OBJEKTORIENTIERTE KONZEPTE................................................ 28
2.1
2.2
2.3
2.4
2.5
2.6
Modellierung mit Klassen und Objekten ................................................. 28
Information Hiding und Kapselung ......................................................... 36
Abstraktion und Brechung der Komplexität ............................................ 37
Erstes Programmbeispiel mit Objekten .................................................. 41
Flughafen-Projekt ................................................................................... 44
Übungen ................................................................................................. 56
3 EINFÜHRUNG IN DIE PROGRAMMIERSPRACHE JAVA ............... 58
3.1
3.2
3.3
3.4
3.5
3.6
3.7
Sprachkonzepte von Java ...................................................................... 58
Eigenschaften von Java ......................................................................... 59
Die Java-Plattform .................................................................................. 60
Programmerzeugung und -ausführung ................................................... 63
Das Java Development Kit ..................................................................... 68
Java-Anwendungen und Internet-Programmierung................................ 71
Übungen ................................................................................................. 72
4 EINFACHE BEISPIELPROGRAMME ............................................... 76
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
Lokale Variablen, Ausdrücke und Schleifen ........................................... 76
Zeichen von der Tastatur einlesen ......................................................... 81
Erzeugen von Objekten .......................................................................... 84
Initialisierung von Objekten mit Konstruktoren ....................................... 85
Schreiben von Instanzmethoden ............................................................ 88
Zusammengesetzte Objekte ................................................................... 92
Selbst definierte Untertypen durch Vererbung ....................................... 96
Die Methode printf() und die Klasse Scanner ......................................... 99
Übungen ............................................................................................... 102
X
Inhaltsverzeichnis
5 LEXIKALISCHE KONVENTIONEN ................................................ 106
5.1
5.2
5.3
5.4
Zeichenvorrat von Java ........................................................................ 106
Der Unicode .......................................................................................... 108
Lexikalische Einheiten .......................................................................... 108
Übungen ............................................................................................... 125
6 DATENTYPEN UND VARIABLEN .................................................. 128
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
Abstrakte Datentypen und Klassen .................................................. 128
Die Datentypen von Java ..................................................................... 130
Variablen............................................................................................... 137
Modifikatoren ........................................................................................ 154
Arrays ................................................................................................... 154
Aufzählungstypen ................................................................................. 165
Konstante und variable Zeichenketten ................................................. 173
Wrapper-Klassen .................................................................................. 185
Boxing und Unboxing............................................................................ 189
Verkettung von Strings und Variablen anderer Datentypen ................. 193
Übungen ............................................................................................... 194
7 AUSDRÜCKE UND OPERATOREN ............................................... 204
7.1
7.2
7.3
7.4
7.5
7.6
7.7
7.8
7.9
Operatoren und Operanden ................................................................. 204
Ausdrücke und Anweisungen ............................................................... 205
Nebeneffekte ........................................................................................ 207
Auswertungsreihenfolge ....................................................................... 207
L-Werte und R-Werte............................................................................ 209
Zusammenstellung der Operatoren ...................................................... 211
Konvertierung von Datentypen ............................................................. 230
Ausführungszeitpunkt von Nebeneffekten ............................................ 239
Übungen ............................................................................................... 240
8 KONTROLLSTRUKTUREN ............................................................ 244
8.1
8.2
8.3
8.4
8.5
Blöcke – Kontrollstrukturen für die Sequenz ........................................ 244
Selektion ............................................................................................... 244
Iteration ................................................................................................. 251
Sprunganweisungen ............................................................................. 258
Übungen ............................................................................................... 261
9 BLÖCKE UND METHODEN ........................................................... 266
9.1 Blöcke und ihre Besonderheiten ........................................................... 266
9.2 Methodendefinition und -aufruf ............................................................. 271
Inhaltsverzeichnis
9.3
9.4
9.5
9.6
9.7
9.8
XI
Polymorphie von Operationen .............................................................. 282
Überladen von Methoden ..................................................................... 284
Parameterliste variabler Länge ............................................................. 286
Parameterübergabe beim Programmaufruf .......................................... 288
Iteration und Rekursion ........................................................................ 290
Übungen ............................................................................................... 296
10 KLASSEN UND OBJEKTE .......................................................... 302
10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
Information Hiding................................................................................. 302
Klassenvariablen und Klassenmethoden ............................................. 304
Die this-Referenz .................................................................................. 310
Initialisierung von Datenfeldern ............................................................ 317
Instantiierung von Klassen ................................................................... 334
Freigabe von Speicher.......................................................................... 336
Die Klasse Object ................................................................................. 341
Übungen ............................................................................................... 342
11 VERERBUNG UND POLYMORPHIE........................................... 354
11.1
11.2
11.3
11.4
11.5
11.6
11.7
11.8
Das Konzept der Vererbung ................................................................. 354
Erweitern und Überschreiben ............................................................... 359
Besonderheiten bei der Vererbung ....................................................... 364
Polymorphie und das Liskov Substitution Principle .............................. 384
Verträge ................................................................................................ 399
Identifikation der Klasse eines Objektes ............................................... 415
Konsistenzhaltung von Quell- und Bytecode ........................................ 420
Übungen ............................................................................................... 423
12 PAKETE ....................................................................................... 432
12.1
12.2
12.3
12.4
12.5
12.6
12.7
12.8
"Programmierung im Großen" .............................................................. 432
Pakete als Entwurfseinheiten ............................................................... 434
Erstellung von Paketen ......................................................................... 435
Benutzung von Paketen ....................................................................... 436
Paketnamen.......................................................................................... 440
Gültigkeitsbereich von Klassennamen ................................................. 444
Zugriffsmodifikatoren ............................................................................ 447
Übungen ............................................................................................... 454
13 AUSNAHMEBEHANDLUNG ....................................................... 464
13.1 Das Konzept des Exception Handlings ................................................ 464
13.2 Implementierung von Exception-Handlern in Java ............................... 466
XII
13.3
13.4
13.5
13.6
13.7
13.8
Inhaltsverzeichnis
Ausnahmen vereinbaren und auswerfen .............................................. 470
Die Exception-Hierarchie ...................................................................... 472
Ausnahmen behandeln ......................................................................... 475
Vorteile des Exception-Konzeptes ........................................................ 482
Assertions ............................................................................................. 483
Übungen ............................................................................................... 488
14 SCHNITTSTELLEN...................................................................... 496
14.1
14.2
14.3
14.4
14.5
14.6
14.7
Trennung von Spezifikation und Implementierung ............................... 496
Ein weiterführendes Beispiel ................................................................ 498
Aufbau einer Schnittstelle ..................................................................... 502
Verwenden von Schnittstellen .............................................................. 505
Vergleich Schnittstelle und abstrakte Basisklasse ............................... 519
Das Interface Cloneable ....................................................................... 522
Übungen ............................................................................................... 529
15 GESCHACHTELTE KLASSEN .................................................... 538
15.1
15.2
15.3
15.4
15.5
15.6
Elementklassen .................................................................................... 540
Lokale Klassen ..................................................................................... 545
Anonyme Klassen ................................................................................. 549
Statische geschachtelte Klassen und Schnittstellen ............................ 554
Realisierung von geschachtelten Klassen ............................................ 557
Übungen ............................................................................................... 562
16 EIN-/AUSGABE UND STREAMS ................................................ 568
16.1
16.2
16.3
16.4
16.5
16.6
16.7
16.8
Für ganz Eilige ein erstes Beispiel ....................................................... 568
Klassifizierung von Streams ................................................................. 572
Das Stream-Konzept ............................................................................ 575
Bytestream-Klassen.............................................................................. 579
Characterstream-Klassen ..................................................................... 591
Standardeingabe und Standardausgabe .............................................. 598
Ein- und Ausgabe von Objekten ........................................................... 601
Übungen ............................................................................................... 609
17 GENERIZITÄT ............................................................................. 614
17.1
17.2
17.3
17.4
17.5
Generische Klassen.............................................................................. 615
Eigenständig generische Methoden ..................................................... 631
Wildcards .............................................................................................. 635
Generische Schnittstellen ..................................................................... 641
Die Klasse Class<T> ............................................................................ 653
Inhaltsverzeichnis
XIII
17.6 Generizität und Polymorphie ............................................................ 657
17.7 Übungen ............................................................................................... 659
18 COLLECTIONS............................................................................ 668
18.1
18.2
18.3
18.4
18.5
18.6
18.7
18.8
Überblick über die Collection-API ......................................................... 669
Iterieren über Collections ...................................................................... 675
Listen .................................................................................................... 677
Warteschlangen .................................................................................... 695
Mengen ................................................................................................. 705
Verzeichnisse ....................................................................................... 713
Besonderheiten bei der Anwendung von Collections ........................... 718
Übungen ............................................................................................... 720
19 THREADS .................................................................................... 724
19.1
19.2
19.3
19.4
19.5
19.6
19.7
Zustände und Zustandsübergänge von Betriebssystem-Prozessen .... 729
Zustände und Zustandsübergänge von Threads.................................. 730
Programmierung von Threads .............................................................. 733
Scheduling von Threads ....................................................................... 741
Zugriff auf gemeinsame Ressourcen .................................................... 742
Daemon-Threads .................................................................................. 765
Übungen ............................................................................................... 766
20 APPLETS ..................................................................................... 772
20.1
20.2
20.3
20.4
20.5
20.6
20.7
Die Seitenbeschreibungssprache HTML .............................................. 773
Das "Hello, world"-Applet...................................................................... 784
Der Lebenszyklus eines Applets .......................................................... 788
Parameterübernahme aus einer HTML-Seite....................................... 793
Importieren von Bildern......................................................................... 794
Importieren und Abspielen von Audio-Clips ......................................... 796
Übungen ............................................................................................... 797
21 OBERFLÄCHENPROGRAMMIERUNG MIT SWING................... 802
21.1
21.2
21.3
21.4
21.5
21.6
21.7
21.8
Architekturmuster Model-View-Controller ............................................. 802
Die Swing-Architektur ........................................................................... 808
Ereignisbehandlung für Swing .............................................................. 811
Integration von Swing in das Betriebssystem ....................................... 827
Swing-Komponenten ............................................................................ 834
Layout-Management ............................................................................. 875
Weitere Technologien der Ein- und Ausgabe ....................................... 892
Übungen ............................................................................................... 894
XIV
Inhaltsverzeichnis
22 SERVLETS .................................................................................. 900
22.1
22.2
22.3
22.4
22.5
22.6
Das Internet und seine Dienste ............................................................ 900
Dynamische Erzeugung von Seiteninhalten ......................................... 908
Web-Anwendungen erstellen ............................................................... 912
Wichtige Elemente der Servlet-API ...................................................... 917
Der Deployment Deskriptor .................................................................. 922
Das Servlet "Forum" ............................................................................. 924
23 JAVASERVER PAGES................................................................ 934
23.1
23.2
23.3
23.4
23.5
Skriptelemente ...................................................................................... 937
Direktiven .............................................................................................. 942
Aktionen ................................................................................................ 946
Verwendung von JavaBeans ................................................................ 949
Tag-Bibliotheken ................................................................................... 954
24 NETZWERKPROGRAMMIERUNG MIT SOCKETS..................... 964
24.1
24.2
24.3
24.4
Verteilte Systeme.................................................................................. 964
Rechnername, URL und IP-Adresse .................................................... 967
Sockets ................................................................................................. 975
Protokolle .............................................................................................. 996
25 REMOTE METHOD INVOCATION ............................................ 1002
25.1
25.2
25.3
25.4
25.5
25.6
Die Funktionsweise von RMI .............................................................. 1002
Entwicklung einer RMI-Anwendung .................................................... 1004
Ein einfaches Beispiel......................................................................... 1009
Object by Value und Object by Reference ......................................... 1015
Verwendung der RMI-Codebase ........................................................ 1028
Häufig auftretende Fehler und deren Behebung ................................ 1043
26 JDBC ......................................................................................... 1046
26.1
26.2
26.3
26.4
26.5
26.6
26.7
26.8
26.9
Einführung in SQL .............................................................................. 1047
JDBC-Treiber ...................................................................................... 1056
Installation und Konfiguration von MySQL ......................................... 1058
Zugriff auf ein DBMS .......................................................................... 1060
Datentypen ......................................................................................... 1085
Exceptions .......................................................................................... 1086
Metadaten ........................................................................................... 1087
JDBC-Erweiterungspaket ................................................................... 1089
Connection Pooling............................................................................. 1090
Inhaltsverzeichnis
XV
27 ENTERPRISE JAVABEANS 3.0 ................................................ 1098
27.1
27.2
27.3
27.4
27.5
27.6
27.7
27.8
27.9
Idee der Enterprise JavaBeans .......................................................... 1099
Objektorientierte Modellierung ............................................................ 1099
Abbildung von Klassen auf Bean-Typen ............................................ 1105
Überblick über die Enterprise JavaBeans-Architektur ........................ 1106
Konzept der EJB-Typen...................................................................... 1111
Session-Beans.................................................................................... 1112
Der Applikations-Server JBoss ........................................................... 1121
Java Persistence API.......................................................................... 1130
Vollständiges Beispiel: Eine einfache Bankanwendung ..................... 1157
ANHANG A DER ASCII-ZEICHENSATZ .......................................... 1171
ANHANG B GÜLTIGKEITSBEREICHE VON NAMEN ..................... 1174
ANHANG C DIE KLASSE SYSTEM ................................................. 1179
ANHANG D JNDI.............................................................................. 1182
ANHANG E ANNOTATIONS ............................................................ 1199
BEGRIFFSVERZEICHNIS ................................................................ 1207
LITERATURVERZEICHNIS .............................................................. 1216
INDEX ............................................................................................... 1218
Kapitel 1
Grundbegriffe der
Programmierung
1.1
1.2
1.3
1.4
1.5
1.6
1.7
Das erste Programm
Vom Problem zum Programm
Nassi-Shneiderman-Diagramme
Zeichen
Variablen
Datentypen
Übungen
1 Grundbegriffe der Programmierung
Bevor man mit einer Programmiersprache umzugehen lernt, muss man wissen, was
ein Programm prinzipiell ist und wie man Programme konstruiert. Damit wird sich das
erste Kapitel befassen. Leser, die bereits eine höhere Programmiersprache erlernt
haben, können prüfen, ob sie tatsächlich die hier präsentierten Grundbegriffe (noch)
beherrschen und gegebenenfalls dieses Kapitel "überfliegen". Ehe es "zur Sache
geht", zunächst als spielerischen Einstieg in Kapitel 1.1 das Programm "Hello, world".
1.1 Das erste Programm
Seit Kernighan und Ritchie ist es Usus geworden, als erstes Beispiel in einer neuen
Programmiersprache mit dem Programm "Hello, world" zu beginnen. Das Programm
"Hello, world" macht nichts anderes, als den Text "Hello, world!" auf dem Bildschirm
auszugeben. In Java sieht das "Hello, world"-Programm folgendermaßen aus:
// Datei: HelloWorld.java
public class HelloWorld
// Klasse zur Ausgabe von "Hello, world!"
{
public static void main (String[] args) // Methode main() zur
{
// Ausgabe der ZeichenSystem.out.println ("Hello, world!"); // kette
}
}
Die Methode println() – sie wird ausgesprochen als print line – wird über
System.out.println() aufgerufen und schreibt die Zeichenkette "Hello, world!"
auf den Bildschirm. Bitte erstellen Sie dieses Programm mit einem Texteditor, der
Ihnen vertraut ist, und speichern Sie es unter dem Dateinamen HelloWorld.java
in einer Datei ab. Dieses Programm besteht aus einer Klasse mit dem Namen
HelloWorld. Eine Klasse ist dadurch gekennzeichnet, dass sie das Schlüsselwort
class trägt. Beachten Sie, dass alles, was hinter zwei Schrägstrichen in einer Zeile
steht, zusammen mit den beiden Schrägstrichen einen so genannten Kommentar
darstellt. Ein Kommentar dient zur Dokumentation eines Programms und hat keinen
Einfluss auf den Ablauf des Programms.
In Java kann man nur objektorientiert programmieren. Alle Programme in Java basieren von ihrem Aufbau her komplett auf
Klassen.
Bitte achten Sie sowohl beim Eintippen des Programms im Texteditor, als auch bei
der Vergabe des Dateinamens auf die Groß- und Kleinschreibung, da in Java
zwischen Groß- und Kleinbuchstaben unterschieden wird. In anderen Worten: Java
ist case sensitiv.
Grundbegriffe der Programmierung
3
Kompilieren Sie das Programm mit dem javac-Compiler1 des Java Development
Kits2 durch die folgende Eingabe auf der Kommandozeile:
javac HelloWorld.java
Danach drücken Sie die <RETURN>-Taste. Auf der <RETURN>-Taste ist oftmals das
Symbol ↵ zu sehen. Der javac-Compiler übersetzt dann den Java-Quellcode der
Datei HelloWorld.java in so genannten Bytecode und legt diesen in der Datei
HelloWorld.class ab. Durch die Eingabe von
java HelloWorld
und das anschließende Drücken der <RETURN>-Taste wird der Bytecode-Interpreter
java gestartet, der den Bytecode interpretiert, d.h. in Maschinencode übersetzt und
zur Ausführung bringt. Hierbei ist Maschinencode ein spezieller Code, den der
entsprechende Prozessor versteht. Java-Anwendungen können – wie hier gezeigt –
von der Kommandozeile aus gestartet werden. Sie können aber auch aus Entwicklungsumgebungen wie z.B. aus Eclipse aufgerufen werden. Bild 1-1 zeigt die
Ein- und Ausgaben in einer Windows-Konsole.
Bild 1-1 Kompilieren und Starten über Kommandos in der Windows-Konsole
Zu beachten ist, dass der Interpreter java den Klassennamen
HelloWorld und nicht den Dateinamen HelloWorld.class
verlangt!
Die Ausgabe des Programms ist:
Hello, world!
Wie Sie bemerkt haben, werden die Anführungszeichen " nicht mit ausgegeben. Sie
dienen nur dazu, den Anfang und das Ende einer Zeichenkette (eines Strings) zu
markieren. So schnell kann es also gehen. Das erste Programm läuft schon. Sie
hatten "ein Händchen" im Umgang mit Texteditor, Compiler und Interpreter. Da es
hier nur darum geht, ein allererstes Programm zu starten, wird auf eine detaillierte
Erläuterung des Programms verzichtet.
1
2
Der Name javac wurde gewählt als Abkürzung für Java Compiler.
Die Installation des Java Development Kits wird in Kap. 3.5.1 beschrieben.
4
Kapitel 1
1.2 Vom Problem zum Programm
Der Begriff Programm ist eng mit dem Begriff Algorithmus verbunden. Algorithmen
sind Vorschriften für die Lösung eines Problems, welche die Handlungen und ihre
Abfolge – kurz, die Handlungsweise – beschreiben. Im Alltag begegnet man Algorithmen in Form von Bastelanleitungen, Kochrezepten und Gebrauchsanweisungen.
Abstrakt kann man sagen, dass die folgenden Bestandteile und Eigenschaften zu
einem Algorithmus gehören:
•
•
•
•
eine Menge von Objekten, die durch den Algorithmus bearbeitet werden,
eine Menge von Operationen, die auf den Objekten ausgeführt werden,
ein definierter Anfangszustand, in dem sich die Objekte zu Beginn befinden,
und ein gewünschter Endzustand, in dem sich die Objekte nach der Lösung des
Problems befinden sollen.
Dies sei am Beispiel Kochrezept erläutert:
Objekte:
Operationen:
Anfangszustand:
Endzustand:
Zutaten, Geschirr, Herd, ...
waschen, anbraten, schälen, passieren, ...
Zutaten im "Rohzustand", Teller leer, Herd kalt, ...
fantastische Mahlzeit auf dem Teller.
Was dann noch zur Lösung eines Problems gebraucht wird, ist eine Anleitung, ein
Rezept oder eine Folge von Anweisungen und jemand, der es macht. Mit anderen
Worten, man benötigt einen Algorithmus – also eine Rechenvorschrift – und einen
Prozessor.
Während aber bei einem Kochrezept viele Dinge gar nicht explizit gesagt werden
müssen, sondern dem Koch aufgrund seiner Erfahrung implizit klar sind – z.B. dass
er den Kuchen aus dem Backofen holen muss, bevor er schwarz ist –, muss einem
Prozessor alles explizit und eindeutig durch ein Programm, das aus Anweisungen
einer Programmiersprache besteht, gesagt werden. Ein Programm besteht aus
einer Reihe von einzelnen Anweisungen an den Prozessor, die von diesem der
Reihe nach – in anderen Worten sequenziell – ausgeführt werden.
Ein Algorithmus in einer Programmiersprache besteht aus Anweisungen, die von einem Prozessor ausgeführt werden können.
Arbeitsspeicher des Rechners
Anweisung
Anweisung
1
2
3
Anweisung
...
Anweisung
Prozessor des Rechners
Anweisung
Anweisung
Bild 1-2 Der Prozessor bearbeitet eine Anweisung des Programms nach der anderen
Grundbegriffe der Programmierung
5
Bild 1-2 zeigt Anweisungen, die im Arbeitsspeicher des Rechners abgelegt sind und
nacheinander durch den Prozessor des Rechners abgearbeitet werden.
1.2.1 Der Euklid’sche Algorithmus als Beispiel für Algorithmen
Als Beispiel wird der Algorithmus betrachtet, der von Euklid ca. 300 v. Chr. zur
Bestimmung des größten gemeinsamen Teilers (ggT) zweier natürlicher Zahlen
aufgestellt wurde. Der größte gemeinsame Teiler wird zum Kürzen von Brüchen
benötigt:
xungekürzt
yungekürzt
=
xungekürzt /ggT(xungekürzt ,yungekürzt )
yungekürzt /ggT(xungekürzt ,yungekürzt )
=
x gekürzt
y gekürzt
Hierbei ist ggT(xungekürzt, yungekürzt) der größte gemeinsame Teiler der beiden Zahlen
xungekürzt und yungekürzt.
Beispiel:
24 24 /ggT ( 24,9 ) 24 / 3 8
=
=
=
9
9 /ggT ( 24,9 )
9/ 3 3
Der Euklid’sche Algorithmus lautet:
Zur Bestimmung des größten gemeinsamen Teilers zwischen zwei natürlichen
Zahlen x und y tue Folgendes3:
Solange x ungleich y ist, wiederhole:
Wenn x größer als y ist, dann:
Ziehe y von x ab und weise das Ergebnis x zu.
Andernfalls:
Ziehe x von y ab und weise das Ergebnis y zu.
Wenn x gleich y ist, dann:
x (bzw. y) ist der gesuchte größte gemeinsame Teiler.
Man erkennt in diesem Beispiel Folgendes:
• Es gibt eine Menge von Objekten, mit denen etwas passiert: x und y. Diese
Objekte x und y haben am Anfang beliebig vorgegebene Werte, am Schluss
enthalten sie den größten gemeinsamen Teiler.
• Es gibt gewisse Grundoperationen, die hier nicht weiter erläutert werden, da sie
implizit klar sind: vergleichen, abziehen und zuweisen.
• Es handelt sich um eine sequenzielle Folge von Anweisungen (Operationen), d.h.
die Anweisungen werden der Reihe nach hintereinander ausgeführt.
• Es gibt aber auch bestimmte Konstrukte, welche die einfache sequenzielle Folge
(Hintereinanderausführung) gezielt verändern: eine Auswahl zwischen Alternativen (Selektion) und eine Wiederholung von Anweisungen (Iteration).
3
Die Arbeitsweise dieses Algorithmus für die Zahlen
Tabelle 1-1 in Kapitel 1.2.3 verdeutlicht.
x == 24 und y == 9 wird anhand der
6
Kapitel 1
Es gibt auch Algorithmen zur Beschreibung von parallelen Aktivitäten, die zum
gleichen Zeitpunkt nebeneinander ausgeführt werden. Diese Algorithmen werden
unter anderem bei Betriebssystemen oder in der Prozessdatenverarbeitung benötigt.
Im Folgenden werden bewusst nur sequenzielle Abläufe behandelt, bei denen zu
einem Zeitpunkt nur eine einzige Operation durchgeführt wird.
1.2.2 Beschreibung sequenzieller Abläufe
Die Abarbeitungsreihenfolge von Anweisungen wird auch als
Kontrollfluss bezeichnet.
Den Prozessor stört es überhaupt nicht, wenn eine Anweisung einen Sprungbefehl
zu einer anderen Anweisung enthält. Solche Sprungbefehle werden in manchen
Programmiersprachen beispielsweise mit dem Befehl GOTO und Marken wie z.B. 100
realisiert:
100
300
IF(a > b) GOTO 100
Anweisungen2
GOTO 300
Anweisungen1
Anweisungen3
In Worten lauten diese Anweisungen an den Prozessor: "Vergleiche die Werte von a
und b. Wenn4 a größer als b ist, springe an die Stelle mit der Marke 100. Führe an
der Stelle mit der Marke 100 die Anweisungen Anweisungen1 aus. Fahre dann mit
den Anweisungen3 fort. Ist aber die Bedingung a > b nicht erfüllt, so arbeite die
Anweisungen Anweisungen2 ab. Springe dann zu der Marke 300 und führe die
Anweisungen Anweisungen3 aus."
Will jedoch ein Programmierer ein solches Programm lesen, so verliert er durch die
Sprünge sehr leicht den Zusammenhang und damit das Verständnis. Für den
menschlichen Leser ist es am besten, wenn ein Programm einen einfachen und
damit überschaubaren Kontrollfluss hat. Während typische Programme der sechziger
Jahre noch zahlreiche Sprünge enthielten, bemühen sich die Programmierer seit
Dijkstras grundlegendem Artikel "Go To Statement Considered Harmful" [1],
möglichst einen Kontrollfluss ohne Sprünge zu entwerfen. Beispielsweise kann der
oben mit GOTO beschriebene Ablauf auch folgendermaßen realisiert werden:
IF(a > b)
Anweisungen1
ELSE
Anweisungen2
ENDIF
Anweisungen3
4
"Wenn“ wird ausgedrückt durch das Schlüsselwort IF der hier verwendeten Programmiersprache
FORTRAN.