Java ist eine Sprache: Java lesen, schreiben und ausführen — Eine präzise und verständliche Einführung

617 Pages·2005·55.625 MB·German

by  Ulrich Grude (auth.)

Ulrich Grude, Jahrgang 1944, hat in Freiburg
Mathematik und in Berlin Informatik studiert,
bei Prof. Ehrig an der TU-Berlin promoviert,
etwa 12 Jahre in der Industrie gearbeitet (bei
IBM, Siemens, PSI und anderen Firmen) und
etwa 3 Jahre bei Prof. Petri in Bonn geforscht.
Seit 1990 ist er Professor am Fachbereich In
formatik und Medien der TFH Berlin (Fachge
biet Programmiersprachen und Compilerbau)
und seit 2004 mit Astrid befreundet.
Boris Schaa (Pseudonym: mef), 1978 in Ber
lin-Lichterfelde geboren, erfand die Comic
figuren Astrid und ihre Freunde. Er studiert
Medieninformatik an der TFH Berlin, spielt
nebenbei E-Gitarre in einer Band, entwickelt
Programme und gestaltet Webseiten. Ein
Astrid-Buch fUr Kinder (kleine und groBe) ist
geplant. Mehr Information gibt es unter
[email protected].
"'Ji
W"r,:, Astrid, die Kurzhalsgiraffe (okapia johnstoni),
~II §) erblickte 1995 das Licht der Comicwelt. Bald
darauf folgte Philipp, das Zebra (equus quag
ga), willkommene Gesellschaft fUr Astrid. In
zwischen gibt es mehr als ein halbes Dutzend
Charaktere, die personliche GruBe in Postkar
tenformat von mef an seine Freunde iibermit
teln und ihm helfen, das Leben zu karikieren.
Fotos von Nicpic Design (www.nicpic.de)
Aus dem Bereich IT erfolgreich lernen
Grundkurs Algorithmen und Das Linux-Tutorial - Ihr Weg
Datenstrukturen in JAVA zum LPI-Zertlflkat
von Andreas Solymosi und Ulrich Grude von Helmut Pils
Grundlegende Algorithmen Grundkurs Wirtschaftslnformatik
von Volker Heun von Dietmar Abts und Wilhelm MUlder
Grundkurs Programmleren mit Delphi Grundkurs Theoretische Informatik
von Wolf-Gert Matthaus von Gottfried Vossen und Kurt-Ulrich Witt
Grundkurs Visual Basic Anwendungsorlentlerte
von Sabine Kamper Wirtschaftslnformatik
Visual Basic fur technlsche von Paul Alpar, Heinz Lothar Grob, Peter
Anwendungen Weimann und Robert Winter
von JUrgen Radel Business Intelligence - Grundlagen
Grundkurs Smalltalk und praktische Anwendungen
Objektorientierung von Anfang an von Hans-Georg Kemper, Walid Mehanna
von Johannes Brauer und Garsten Unger
Grundkurs Software-Entwlcklung Grundkurs
mit C++ Geschiftsprozess-Management
von Dietrich May von Andreas Gadatsch
Grundkurs JAVA Controlling mit SAP R/3®
von Dietmar Abts von Gunther Friedl, Christian Hilz
und Burkhard Pedell
Aufbaukurs JAVA
von Dietmar Abts Kostentrigerrechnung mit SAP R/3®
von Franz Klenger und Ellen Falk-Kalms
Grundkurs java-Technologlen
von Erwin Merker Kostenstellenrechnung mit SAP R/3®
von Franz Klenger und Ellen Falk-Kalms
Objektorientierte
Programmierung In JAVA Prozessmodellierung mit ARIS ®
von Otto Rauh von Heinrich Seidl meier
Grundkurs Informatlk ITIL kompakt und verstindlich
von Hartmut Ernst von Alfred Olbrich
Das PC Wissen fur IT-Berufe Grundkurs Betriebswirtschaftslehre
von Rainer Egewardt von Notger Carl, Rudolf Fiedler, William J6rasz
und Manfred Kiesel
Rechnerarchltektur
von Paul Herrmann Masterkurs IT-Controlling
von Andreas Gadatsch und Elmar Mayer
Grundkurs Relationale Datenbanken
von Rene Steiner Masterkurs Computergrafik
Grundkurs Datenbankentwurf und Bildverarbeitung
von Helmut Jarosch von Alfred Nischwitz und Peter Haberacker
Datenbank-Englneering Grundkurs Mediengestaltung
von Alfred Moos von David Starmann
Grundlagen der Rechnerkommunlkatlon Grundkurs We~Programmierung
von Bernd Schurmann von Gunter Pomaska
Netze - Protokolle - Spezifikatlonen We~Programmierung
von Alfred Olbrich von Oral Avcl, Ralph Trittmann und Werner Mellis
Grundkurs Verteilte Systeme Grundkurs MySQL und PHP
von Gunther Bengel von Martin Pollakowski
Grundkurs Grundkurs SAP R/3®
Mobile Kommunlkatlonssysteme von Andre Maassen und Markus Schoenen
von Martin Sauter java ist eine Sprache
Grundkurs UNIX/Linux von Ulrich Grude
von Wilhelm Schaffrath
Ulrich Grude
Java ist eine Sprache
Java lesen, schreiben und
ausfuhren - Eine prazise
und verstandliche Einfuhrung
lIIustriert von Boris Schaa
aI
vleweg
Bibliografische Information Der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte bibliografische Daten sind im Internet uber <http://dnb.ddb.de> abrufbar.
1. Auflage Marz 2005
Aile Rechte vorbehalten
© Friedr. Vieweg & Sohn Verlag/GWV Fachverlage GmbH, Wiesbaden 2005
Lektorat: Dr. Reinald Klockenbusch / Andrea BroBler
Der Vieweg Verlag ist ein Unternehmen von Springer Sciene + Business Media.
www.vieweg-it.de
Das Werk einschlieBlich aller seiner Teile ist urheberrechtlich geschutzt. Jede
Verwertung auBerhalb der engen Grenzen des Urheberrechtsgesetzes ist
ohne Zustimmung des Verlags unzulassig und strafbar. Das gilt insbesondere
fur Vervielfaltigungen, Obersetzungen, Mikroverfilmungen und die Ein
speicherung und Verarbeitung in elektronischen Systemen.
Konzeption und Layout des Umschlags: Ulrike Weigel, www.CorporateDesignGroup.de
S. III: IIlustriert von Boris Schaa
Umschlagbild: Nina Faber de. sign, Wiesbaden
ISBN-I3: 978-3-528-05914-9 e-TSBN-13: 978-3-322-80263-7
DOl: 10.1007/978-3-322-80263-7
Vorwort
In dies em Buch wird die Programmiersprache Java (in ihrer neusten Version 5.0)
dargestellt. Dabei wird nicht nur beschrieben, wie die Sprache ist, sondern an vie
len Stellen auch, warum sie so ist, wie sie ist. Diese Stellen sollen beim Leser
moglichst viele und intensive Aha-Erlebnisse (und moglichst selten ein Galmen)
auslOsen.
AuBerdem werden einige Teile der Sprache Java bewertet, viele als besonders gut,
aber einige auch als weniger gelungen. Diese Bewertungen haben notwendig eine
subjektive Komponente (bedingt durch die speziellen und beschrankten Erfahrun
gen des Autors). Der Leser soUte sie kritisch prtifen und eventuell abweichende
Ansichten entwickeln. Auf jeden Fall kann eine Beschaftigung mit Bewertungen
zu einem tieferen Verstandnis einer Programmiersprache und der Programrnierung
im AHgemeinen beitragen (und, das sei hier nicht verschwiegen, zu hitzigen Dis
kussionen flihren und Streit zwischen Freunden verursachen).
Dieses Buch soU die Sprache Java moglichst einfach und verstandlich darstellen
(wie weit das miss- oder gelungen ist, kann nur der Leser entscheiden). Dazu wer
den vor aHem zwei Techniken eingesetzt: Abstraktion und kurze Definitionen fur
alle Grundbegriffe.
Abstraktion wird dazu verwendet, urn von vielen komplizierten Einzelheiten abzu
sehen, statt sie dem Leser aufzubtirden. So wird z. B. eine Variable nieht als ein
Abschnitt in einem Computer-Hauptspeicher, der aus J6-Pin-SDR-RAM-Chips
mit einer Versorgungsspannung von 2,5 Volt besteht beschrieben, sondern (abs
trakter und hoffentlich einfacher) als ein BeMlter fur Werte.
Was eine Variable, ein Wertebehdlter und ein Wert ist, wird nieht als allgemein
bekannt vorausgesetzt, sondern kurz erHiutert und dann in einer Definition zusam
mengefasst. Diese Definitionen findet man auch in einem Glossar am Ende des
Buches (vor einem kurzen Literaturverzeichnis und einem umfangreiehen Sach
wortverzeichnis ).
Java wird hier als eine Sprache dargestellt, in der ein Programrnierer Befehle for
mulieren kann, urn sie von einem Ausflihrer ausftihren zu lassen. Die Befehle wer
den unter anderem dadurch erkllirt, dass sie ins Deutsche tibersetzt werden (z. B.
der Java-Befehl int x = 17; in den Satz "Erzeuge eine Variable namens x vom
Typ in t mit dem Anfangswert 17 !"). Dieses Ubersetzen wird relativ einfach,
wenn man erkennt, dass es eigentlich nur drei Arten von Befehlen gibt und die
Ubersetzung eines Befehls vor aHem von seiner Art abhlingt. Dem Leser wird
empfohlen, die von ihm formulierten Befehle auch selbst "mit Papier und Bleistift"
V
auszuftihren. Dazu braucht man zwar meistens deutlich mehr Zeit aIs ein
Computer, lemt die Befehle aber besonders griindlich kennen (oder merkt, dass
man sie noch nicht genau genug verstanden hat, urn sie auszuftihren).
Viele Menschen haben zu diesem Buch beigetragen. Meinem langjiihrigen Freund
Friedrich Wilhelm Schroer mochte ich fiir zahllose Anregungen und Einsichten
danken, die er mir in vie1en Gesprachen verrnittelt hat. Insbesondere gehen einige
der kritischen Anmerkungen zu Java direkt auf seine Ansichten zuruck. Vermutlich
stammen auch einige Ideen, die ich jetzt flir meine eigenen halte, aus lange zuruck
liegenden Diskussionen mit ihm.
Meinem Kollegen Andreas Solymosi danke ich flir viele anregende Gesprache
tiber Prograrnrnierung im Allgemeinen und Java im Speziellen. Besonders span
nend waren diese Gesprache, weil wir bei formalen Fragen meist sehr schnell tiber
einstimmten, bei konzeptionellen Problemen dagegen haufig ganz verschiedener
Ansicht waren. Andreas hat auch einen Entwurf dieses Buchs vollstandig gelesen
und mich auf viele Fehler und Schwachstellen aufmerksam gemacht.
Auch meiner Kollegin Fanny-Michaela Reisin danke ich flir viele Gesprache und
Anregungen. Auf sie (und ihre Studentlnnen) geht eine Modifikation der Bojen
darstellung von Variablen zuruck, die ich gem iibemommen habe (nach einigen
Wochen des Zogems, die ich brauchte, urn die Vorteile der Modifikation zu ver
stehen).
Meiner Frau Barbara danke ich fiir die aktive HiIfe beim Korrekturlesen des Ma
nuskripts und beim kritischen Durchsehen einiger KapiteI, vor aHem aber dafiir,
dass sie mich ertragen hat, wiihrend ich an dem Buch schrieb (es ist wohI nicht
immer einfach, einen Buch-schreibenden Mann zu ertragen).
Herr Klockenbusch yom Vieweg-Verlag hat mich im richtigen Moment unterstiitzt
und beraten und einen passenden TiteI ftir das Buch gefunden. Herr Erwin Merker
half mir aIs Gutachter des Verlags mit vieIen ntitzIichen VerbesserungsvorschHi
gen und Hinweisen auf Fehler. Auch ihnen vielen Dank.
SchlieBlich mochte ich mich bei allen Studentlnnen der TFH Berlin bedanken, die
Vorlaufer dieses Buches in Skriptform durcharbeiten mussten. Sie haben mich auf
zahlreiche Fehler und Schwachen aufmerksam gemacht, im Ganzen aber mein
Buchprojekt eher mit wohlwollendem Interesse unterstiitzt (oder habe ich da be
stimmte positive Bemerkungen kurz vor einer Prufung missverstanden? :-)).
Berlin, im Januar 2005, Ulrich Grude.
VI
Inhaltsverzeichnis
1 Einleitung ............................................................................................................. 1
1.1 Programmieren als Rollenspiel.. ..................................................................... 1
1.2 Das unvermeidliche Hallo-Programm. ......................................................... ..4
1.3 Beispielprogramme und konkrete Ausftihrer.. ................................................ 7
1.4 Die vier wichtigsten Grundkonzepte von Programmiersprachen ............... .12
1.4.1 Das Konzept einer beliebig oft vedinderbaren Variablen ..................... .12
1.4.2 Das Konzept eines Typs .......................................................................... 13
1.4.3 Das Konzept eines Unterprogramms ...................................................... 15
1.4.4 Das Konzept eines Moduls ..................................................................... 17
l.4.5 Das Konzept einer Klasse ...................................................................... .19
1.5 Drei Arten von Befehlen ............................................................................... 19
1.5.1 Vereinbarungen (declarations) ................................................................ 20
1.5.2 Ausdrucke (expressions) ......................................................................... 22
1.5.3 Anweisungen(statements) ....................................................................... 25
2 Ein paar kleine Beispielprogramme. .............................................................. 27
2.1 Prozeduren mit Parametern ........................................................................... 27
2.2 Funktionen mit Parametern ........................................................................... 29
2.3 Mehrere Klassen, ein Programm .................................................................. 31
2.4 Daten von der Tastatur einlesen ................................................................... 32
2.5 Befehle wiederholt ausfiihren lassen ............................................................ 34
2.6 Befehle von einer Bedingung abhangig machen .......................................... 35
2.7 Ein zusammenfassendes BeispieL ............................................................... 38
3 Programme selbst ausfiihren. .......................................................................... 41
4 Anweisungen (statements) ............................................................................... 46
4.1 Einfache Anweisungen (simple statements) ................................................ .47
4.1.1 Die Zuweisung ......................................................................................... 47
4.1.2 Methodenaufrufe ..................................................................................... 50
4.1.3 Inkrement- und Dekrementanweisungen ................................................ 50
4.l.4 Die Anweisungen break und continue .................................................... 51
4.1.5 Die return-Anweisung ............................................................................. 53
4.1.6 Die leere Anweisung ............................................................................... 56
4.1.7 Die throw-Anweisung .............................................................................. 57
4.1.8 Die assert-Anweisung .............................................................................. 57
4.2 Zusammengesetzte Anweisungen (compound statements) .......................... 58
4.2.1 Die Blockanweisung ................................................................................ 58
4.2.2 Die if-Anweisung ..................................................................................... 60
VII
4.2.3 Die switch-Anweisung ............................................................................ 65
4.2.4 Die while- und die do-while-Anweisung ................................................ 68
4.2.5 Die for-Anweisung .................................................................................. 73
4.2.6 Schleifen selbst ausftihren ....................................................................... 78
4.2.7 Endliche und endlose Schleifen .............................................................. 82
4.2.8 Geschachtelte Schleifen .......................................................................... 84
5 TypeD .................................................................................................................. 89
5.1 Primitive Typen, eine Ubersicht.. ................................................................. 91
5.2 Numerische Werte umwandeln (Cast-Befehle) ............................................ 95
5.3 Mit primitiven Werten rechnen ................................................................... 103
5.4 Gleitpunktarithmetik. .................................................................................. l 06
5.5 Ganzzahlarithmetik ..................................................................................... 111
5.6 Besonderheiten des Ganzzahltyps char ...................................................... 114
5.7 Variablen als Bojen darstellen .................................................................... 117
5.8 Autohtillen (auto boxing) ............................................................................ 128
6 Ausdriicke, einfache UDd zusammeDgesetzte ............................................... 129
6.1 Einfache Ausdriicke (Literale und Variablennamen) ................................. 132
6.2 Zusammengesetzte Ausdriicke und Operatoren ......................................... 138
7 Reihongen (arrays) ......................................................................................... 150
7.1 Reihungen vereinbaren und als Bojen darstellen ....................................... 155
7.2 Die Erzeugung einer Reihung in 3 Schritten .............................................. 161
7.3 Reihungen auf verschiedene Weisen kopieren ........................................... 162
7.4 Mehrstufige Reihungen (Reihungen von Reihungen) ................................ 165
7.5 Mehrdimensionale Reihungen .................................................................... 169
7.6 Reihungen vergleichen und sortieren ......................................................... 170
7.7 Die Klasse Arrays ....................................................................................... 172
7.8 Initialisierungen sind keine Zuweisungen .................................................. 173
7.9 Das Kovarianz-Problem bei Reihungstypen ............................................... 173
8 Methoden vereinbaren ODd aufrufen ........................................................... 182
8.1 Parameteriibergabe per Wert ...................................................................... 184
8.2 Prozeduren und Funktionen ........................................................................ 190
8.3 Methodennamen tiberladen ......................................................................... 193
8.4 Methoden mit variabel vielen Parametem .................................................. 196
8.5 Kommentare ftir Methoden ......................................................................... 197
9 Klassen ............................................................................................................. 201
9.1 Eine kleine Beispielklasse ........................................................................... 203
9.2 Eine Klasse mit Attributen eines Referenztyps .......................................... 211
VIII
9.3 Extreme Klassen .......................................................................................... 213
9.4 Klassische Fachbegriffe .............................................................................. 216
9.5 Objektorientierte Programmierung ............................................................. 219
10 Ein paar Standardklassen und Methoden ................................................... 221
10.1 Die Klasse String .........................................................................................2 22
10.2 Objekte mit Hilfe von Bojen genauer verstehen ........................................2 28
10.3 Die Klasse StringBuilder. ........................................................................... 233
10.4 Die Klasse ArrayList.. .................................................................................2 37
10.5 Die Klasse Random und der Zufall ............................................................ 245
10.6 Die Klassen Biglnteger und BigDecimal... ................................................2 47
10.6.1 Die Klasse Biglnteger. .......................................................................... 249
10.6.2 Die Klasse BigDecimal... ......................................................................2 51
10.7 Die Klasse Formatter und die printf-Methoden .........................................2 56
10.7.1 Konkrete Beispiele fUr printf-Befehle .................................................. 257
10.7.2 Die printf-Methode praktisch kennen lemen ........................................ 265
10.7.3 Ubersicht tiber aIle Umwandlungsbefehle ............................................ 266
11 Struktur und Ausftihrung eines Java-Programms ..................................... 272
12 Klassen erweitern (beerben) und Typgrafen ............................................... 276
12.1 Ein kleines Beispiel fUr Beerbung ..............................................................2 77
12.2 Allgemeine Regeln zum Beerben und Vererben ........................................ 283
12.3 Ein groBeres Beispiel fiir Beerbung ........................................................... 286
12.4 Wow Untertypen gut sind .......................................................................... 294
12.5 Kleinere und groBere Klassen und Objekte ................................................3 00
12.6 Konstruktoren in Unterklassen ................................................................... 302
12.7 Der Typ und der Zieltyp einer Referenzvariablen ..................................... 303
12.8 Referenzwerte umdeuten (Cast-Befehle) .................................................... 305
12.9 Geerbte Elemente ersetzen ..........................................................................3 08
12.10 Uberschriebene Methoden in geerbten Methoden aufrufen ....................... 317
12.11 Erweitem oder instanziieren? ....................................................................3 20
12.12 Klassen- und Objektinitialisierer.. .............................................................. 324
13 Aufzahlungstypen (enum types ) .................................................................... 328
13.1 Ein paar einfache Beispiele ......................................................................... 328
13.2 Ein Aufzahlungstyp ist eine Klasse ............................................................3 30
13.3 Aufzahlungstypen und static import ........................................................... 333
14 Abstrakte Klassen und Schnittstellen ........................................................... 335
14.1 Abstrakte Klassen ........................................................................................ 336
14.2 Schnittstellen (interfaces) ............................................................................ 341
IX