Praktische Informatik - Eine Einfuhrung: Lehr- und Arbeitsbuch mit Tafelbildern

262 Pages·2012·8.32 MB·German

by  Gregor Büchel (auth.)

Praktische Informatik – Eine Einführung
Gregor Büchel
Praktische Informatik –
Eine Einführung
Lehr- und Arbeitsbuch mit Tafelbildern
Mit 65 Abbildungen und 13 Tabellen
Prof. Dr. Gregor Büchel
Fachhochschule Köln
Fakultät für Informations-,
Medien- und Elektrotechnik
Lehrgebiet: Datenbanken und Algorithmen
Köln, Deutschland
ISBN 978-3-8348-1874-4 ISBN 978-3-8348-2283-3 (eBook)
DOI 10.1007/978-3-8348-2283-3
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
Springer Vieweg
© Vieweg+Teubner Verlag | Springer Fachmedien Wiesbaden 2012
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht aus-
drücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags. Das
gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die Ein-
speicherung und Verarbeitung in elektronischen Systemen.
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk be-
rechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der
Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann
benutzt werden dürften.
Einbandentwurf: KünkelLopka GmbH, Heidelberg
Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier
Springer Vieweg ist eine Marke von Springer DE. Springer DE ist Teil der Fachverlagsgruppe Springer
Science+Business Media.
www.springer-vieweg.de
Vorwort
Das Buch „Praktische Informatik – Eine Einführung | Lehr- und Arbeitsbuch mit
Tafelbildern“ ist aus meiner Vorlesung entstanden, die ich seit 2002 als Einführung
in die Praktische Informatik für Studierende der Nachrichtentechnik und der
Technischen Informatik an der Fachhochschule Köln anbiete. Mit der Vorlesung ist
ein Programmierpraktikum verbunden, das auf Grundlage der Programmierspra-
chen Java und teilweise C stattfindet. Die Vorlesung wird jährlich im Mittel von ca.
60 Studierenden besucht.
Im akademischen Jahr 2009/10 hatte ich eine sehr engagierte Diskussion mit mei-
nen Studierenden, ob ich zu meiner Vorlesung einen Lehr- bzw. Lerntext als Ar-
beitsbuch verfassen soll. Bis dahin hatte ich eine negative Meinung dazu, da es
viele Lehrbücher der Informatik und eine Reihe einführender Bücher in Java gibt,
auf die ich unter anderem mit einem Literaturverzeichnis zur Vorlesung hinweise.
Darüber hinaus hat die FH Köln eine sehr schöne und gut bestückte Hochschul-
bibliothek. Mein Argument, dass eine Vorlesung eine besondere Art der Wissens-
vermittlung ist, die mit der Deutlichkeit des gesprochenen Worts und der Klarheit
des mit dem Auditorium entwickelten Tafelbildes lebt und deshalb keiner Abfas-
sung in Buchform bedarf, konnte meine Studierenden nicht überzeugen. Sie ver-
langten die Abfassung als Buch mit dem Argument der besseren Möglichkeit der
Vorbereitung der nächsten Vorlesungen und Prüfungen. Dieses Argument über-
zeugte mich letztlich.
Kern des Buches sind meine Tafelbilder, die aus strukturierten Texten und Abbil-
dungen bestehen. Das Layout ist mit einem etwas größeren unteren Rand gestaltet,
damit das Buch tatsächlich ein Arbeitsbuch ist, so dass die Studierenden auf dem
Rand die Möglichkeit haben, die Tafelbilder und Texte des Buches durch eigene
Marginalien zu ergänzen, um sich selber den Stoff zu verdeutlichen, oder ergän-
zende Ausführungen der Vorlesungen zu notieren. Am Ende jedes Kapitels sind
Lernziele notiert, die jeder Leser nach dem Durcharbeiten des Kapitels erreichen
soll.
Das Buch ist wie die Vorlesung an Studierende der ersten beiden Semester gerich-
tet, die ein Interesse an Informatik haben, aber weder über Programmierkenntnisse
noch über Vorkenntnisse auf dem Gebiet der Informatik verfügen. Es ist ein Ein-
führungsbuch, das sich ebenso an Studierende anderer Studiengänge richten kann,
die im Grundstudium ein Pflichtfach Informatik haben (zum Beispiel in wirt-
schaftswissenschaftlichen Studiengängen) oder die Informatik mit einem Program-
mierpraktikum als Nebenfach studieren.
VI Vorwort
Der Ansatz des Buches ist elementar. Im Zentrum steht die Frage der Programmie-
rung, das heißt, es steht die Frage, was getan werden muss und was man wissen
muss, wenn man den Computer veranlassen möchte, formalisierbare Operationen
menschlichen Denkens, wie zum Beispiel die Ausführung der vier Grundrechen-
arten, an Stelle des Menschen maschinell zu erledigen. Die Programmierung setzt
die genaue Beschreibung der Arbeitsschritte zur „logischen“ Lösung des gestellten
Problems voraus, bevor auch nur die erste Zeile Kode in einer Programmierspra-
che wie C oder Java geschrieben ist. Daher wird Wert auf die Vorstellung von Be-
schreibungsmitteln für Algorithmen, für das Programmdesign und für die Spezi-
fikation von Klassen gelegt.
In Jahrzehnten, in denen einerseits komfortable Computer zu wohlfeilen Preisen
angeboten werden, in denen aber andererseits das persönliche schriftliche Dividie-
ren beginnt eine aussterbende Kulturtechnik zu werden, ist es nicht sicher, ob das
Programmieren „einfacher“ wird. Sicher ist, dass die „logische“ Lösung von Pro-
blemen erfordert, „die Anstrengung des Begriffs auf sich zu nehmen“1. Das Buch
stellt eine Hilfe dar, Probleme mit gut durchdachter Abstraktion zu vereinfachen,
den Digitalrechner mit seinen Stärken zu nutzen und die angehenden Program-
miererinnen und Programmierer in der Position zu stärken, dass der Mensch über
der Maschine steht.
Das Buch ist meiner geliebten Frau Gabriela Isabelle gewidmet, die alle Phasen der
Erstellung mit großem Interesse und vielen schönen Gestaltungs- und Formulie-
rungsvorschlägen unterstützte.

Bonn, im Frühjahr 2012 Gregor Büchel

1 Georg W. F. Hegel: „Phänomenologie des Geistes“, Vorrede, Theorie Werkausgabe,
Bd. 3, Frankfurt am Main 1970, S. 56.
Inhalt
Vorwort ........................................................................................................................ V
1 Was ist Informatik? ............................................................................................ 1
1.1 Datenflusspläne ........................................................................................ 2
1.1.1 Symbole eines Datenflussplans ................................................ 2
1.1.2 Beispiel: DFP eines Kinokartenreservierungsystems
(CINRES) ...................................................................................... 3
1.2 Übung ........................................................................................................ 4
1.3 Lernziele zu Kapitel 1 .............................................................................. 4
2 Der Aufbau eines programmierbaren Digitalrechners ............................... 5
2.1 Übungen .................................................................................................... 6
2.2 Allgemeines Schichtenmodell eines programmierbaren
Digitalrechners ......................................................................................... 7
2.2.1 Erläuterungen zur Hardware .................................................... 8
2.2.2 Erläuterungen zur Betriebssoftware ........................................ 10
2.3 Umrechnung von Dezimalzahlen in Binär- und Hexadezimalzahlen 11
2.4 Übungen .................................................................................................... 15
2.5 Lernziele zu Kapitel 2 .............................................................................. 15
3 Vom Problem zum Programm .......................................................................... 17
3.1 Übungen .................................................................................................... 22
3.2 Lernziele zu Kapitel 3 .............................................................................. 22
4 Einführung in die Java-Programmierung ...................................................... 23
4.1 Die Entwicklung eines Java-Programms .............................................. 23
4.1.1 Übungen ...................................................................................... 25
4.2 Allgemeiner Aufbau eines Java-Programms ....................................... 25
4.2.1 Übung ........................................................................................... 29
4.3 Ein Datentyp für ganze Zahlen (int) und arithmetische Ausdrücke 29
4.3.1 Übungen ...................................................................................... 33
4.4 Numerische Vergleichsausdrücke und eine Schleife
für die Programmierung von Wiederholungen ................................... 34
4.4.1 Übungen ...................................................................................... 36
4.5 Lernziele zu Kapitel 4 .............................................................................. 37
VIII Inhalt
5 Steueranweisungen und Struktogramme ...................................................... 39
5.1 Eine Methode zum Einlesen einer Integer-Zahl von der Tastatur .... 39
5.2 Die If-Anweisung ..................................................................................... 40
5.3 Kopfgesteuerte Schleifen ......................................................................... 42
5.4 Fußgesteuerte Schleifen ........................................................................... 43
5.5 Die Mehrfachverzweigung (switch-Anweisung) ................................ 44
5.6 Kontrollierte Abbrüche ........................................................................... 46
5.7 Logische Ausdrücke und der Datentyp boolean ................................. 47
5.7.1 Übung ........................................................................................... 51
5.7.2 Übung ........................................................................................... 52
5.8 Struktogramme ......................................................................................... 53
5.8.1 Übungen ...................................................................................... 56
5.9 Der Euklidische Algorithmus zur Berechnung des größten
gemeinsamen Teilers zweier ganzer Zahlen ........................................ 56
5.9.1 Übungen ...................................................................................... 64
5.10 Lernziele zu Kapitel 5 .............................................................................. 65
6 Gleitpunktzahlen, mathematische Funktionen, weitere ganzzahlige
Datentypen .......................................................................................................... 67
6.1 Gleitpunktzahlen, die Datentypen float und double .......................... 67
6.2 Konvertierung: int-Variablen (cid:316) float-/double-Variablen .................. 72
6.2.1 Explizite Konvertierung ............................................................. 72
6.2.2 Implizite Konvertierung ............................................................ 73
6.3 Mathematische Funktionen .................................................................... 74
6.3.1 Mathematische Konstanten ....................................................... 75
6.3.2 Potenzfunktionen ....................................................................... 75
6.3.3 Trigonometrische Funktionen ................................................... 76
6.3.4 Die Logarithmusfunktion .......................................................... 77
6.3.5 Betrag, Minimum und Maximum ............................................ 78
6.3.6 Abschneiden und Runden ......................................................... 78
6.3.7 Arcusfunktionen ......................................................................... 79
6.3.8 Pseudozufallszahlen ................................................................... 81
6.4 Weitere ganzzahlige Datentypen ........................................................... 83
6.4.1 Übung ........................................................................................... 83
6.5 Lernziele zu Kapitel 6 .............................................................................. 85
7 Felder (Arrays) .................................................................................................... 87
7.1 Grundlegende Eigenschaften ................................................................. 87
7.2 Arbeitsschritte zur Verarbeitung von Feldern ..................................... 87
7.2.1 (S1) Deklaration eines Feldes .................................................... 88
7.2.2 (S2) Speicherplatzbeschaffung für ein Feld ............................. 89
7.2.3 (S3) Wertzuweisung an eine Feldkomponente ....................... 89
Inhalt IX
7.3 Mehrfach indizierte Felder ...................................................................... 93
7.3.1 (S1) Deklaration eines mehrfach indizierten Feldes .............. 94
7.3.2 (S2) Speicherplatzbeschaffung für ein mehrfach
indiziertes Feld ............................................................................ 94
7.3.3 (S3) Wertzuweisung an eine Feldkomponente ....................... 94
7.4 Feldbasierte Algorithmen ....................................................................... 95
7.4.1 Das Horner Schema .................................................................... 96
7.4.2 Erläuterung zum Struktogramm des Horner Schemas ......... 97
7.5 Übungen .................................................................................................... 98
7.6 Lernziele zu Kapitel 7 .............................................................................. 98
8 Statische Methoden ............................................................................................ 99
8.1 Grundlagen ............................................................................................... 99
8.1.1 Übung ........................................................................................... 103
8.2 Modulübersichtsdiagramme .................................................................. 104
8.3 Felder und Methoden .............................................................................. 105
8.3.1 Übungen ...................................................................................... 106
8.4 Der Bubble Sortieralgorithmus .............................................................. 107
8.4.1 Übung ........................................................................................... 109
8.5 Das Sieb des Eratosthenes zur Bestimmung von Primzahlen ............ 110
8.6 Aufrufprinzipien für Methoden: Call by Value,
Call by Reference ...................................................................................... 116
8.7 Lernziele zu Kapitel 8 .............................................................................. 121
9 Zeichen und Zeichenketten .............................................................................. 123
9.1 Zeichen: Der Datentyp char .................................................................... 123
9.2 Die Klasse String als Datentyp für Zeichenketten ............................... 131
9.2.1 Vergleichen von Zeichenketten ................................................ 133
9.2.2 Felder von Zeichenketten .......................................................... 135
9.2.3 Zeichenketten und Zeichenfelder ............................................. 140
9.2.4 Verketten und Zerschneiden von Zeichenketten ................... 142
9.2.5 Konvertierung: Zeichenketten <-> Zahlen ............................... 145
9.3 Lernziele zu Kapitel 9 .............................................................................. 149
10 Das Klassenkonzept einer objektorientierten Programmiersprache ........ 151
10.1 Klassen mit Attributen ............................................................................ 151
10.1.1 Anwendung von Klassen mit Attributen ................................ 154
10.2 Klassen mit Attributen und Methoden ................................................. 159
10.3 Konstruktoren ........................................................................................... 162
10.4 Kapselung .................................................................................................. 166
X Inhalt
10.5 Vererbung ................................................................................................. 169
10.6 Überladen und Überschreiben von Methoden .................................... 175
10.7 Lernziele zu Kapitel 10 ............................................................................ 178
11 Zeichenorientierte Dateiverarbeitung ............................................................ 181
11.1 Allgemeine Vorbereitungen ................................................................... 182
11.2 Schreibender zeichenorientierter Zugriff .............................................. 182
11.2.1 Öffnen einer Datei zum Schreiben ........................................... 182
11.2.2 Öffnen einer Datei zum Schreiben mit Anhängen
am Dateiende .............................................................................. 183
11.2.3 Zuordnung eines Methodeninventars für
das zeichenorientierte Schreiben .............................................. 183
11.2.4 Schreiben eines Datensatzes ...................................................... 184
11.2.5 Schließen des schreibenden Zugriffs ....................................... 184
11.3 Lesender zeichenorientierter Zugriff ..................................................... 185
11.3.1 Öffnen einer Datei zum Lesen .................................................. 185
11.3.2 Zuordnung eines Methodeninventars für
das zeichenorientierte Lesen ..................................................... 186
11.3.3 Lesen eines Datensatzes als Zeichenkette ............................... 186
11.3.4 End of File (=: EOF) Steuerung beim Lesen einer Datei ........ 186
11.3.5 Schließen des lesenden Zugriffs ............................................... 187
11.4 Lernziele zu Kapitel 11 ............................................................................ 188
12 Listen .................................................................................................................... 189
12.1 Deklaration einer Liste ............................................................................ 191
12.2 Speicherplatzbeschaffung für eine Liste ............................................... 192
12.3 Einfügen von Knoten an das aktuelle Listenende ............................... 193
12.4 Die Länge einer Liste ermitteln .............................................................. 193
12.5 Lesender Zugriff auf einen Knoten der Liste ....................................... 193
12.6 Löschen eines Knotens aus der Liste ..................................................... 194
12.7 Überschreiben eines Knotens mit einem neuen Inhalt ........................ 194
12.8 Hinzufügen eines Knotens an eine i. Position ...................................... 195
12.9 Eine Liste in ein Feld konvertieren ........................................................ 195
12.10 Lesen einer Liste mit einem Iterator ...................................................... 196
12.11 Lernziele zu Kapitel 12 ............................................................................ 197
13 Formale Spezifikation syntaktischer Strukturen ......................................... 199
13.1 Zur Syntax von natürlichen und formalen Sprachen .......................... 199
13.2 Beschreibung einer Grammatik durch eine BNF ................................. 203
13.2.1 Beschreibung von Nichtterminalsymbolen ............................. 203
Inhalt XI
13.2.2 Beschreibung von Produktionsregeln ...................................... 204
13.2.3 Operatoren im REGELAUSDRUCK einer BNF ...................... 204
13.3 Lernziele zu Kapitel 13 ............................................................................ 207
14 Byteorientierte Dateiverarbeitung/Serialisierung von Klassen ................ 209
14.1 Schreibender serialisierter Zugriff ......................................................... 211
14.1.1 Öffnen einer Datei zum Schreiben ........................................... 211
14.1.2 Zuordnung eines Methodeninventars für
das serialiserte Schreiben ........................................................... 212
14.1.3 Schreiben eines Datensatzes ...................................................... 212
14.1.4 Schließen des schreibenden Zugriffs ....................................... 213
14.2 Lesender serialisierter Zugriff ................................................................ 213
14.2.1 Öffnen einer Datei zum Lesen .................................................. 213
14.2.2 Zuordnung eines Methodeninventars für
das serialisierte Lesen ................................................................. 213
14.2.3 Lesen einer Instanz ..................................................................... 213
14.2.4 End of File (=: EOF) Steuerung beim serialisierten Lesen
einer Datei .................................................................................... 214
14.2.5 Schließen des lesenden Zugriffs ............................................... 215
14.3 Lernziele zu Kapitel 14 ............................................................................ 220
15 Mengen ................................................................................................................. 221
15.1 Deklaration einer Menge ......................................................................... 222
15.2 Speicherplatzbeschaffung für eine Menge ............................................ 222
15.3 Einfügen von Elementen in eine Menge ............................................... 223
15.4 Die Mächtigkeit (Anzahl der Elemente) einer Menge ermitteln ........ 225
15.5 Löschen eines Elements aus der Menge ................................................ 225
15.6 Prüfen, ob die Menge leer ist .................................................................. 226
15.7 Lesen einer Menge mit einem Iterator .................................................. 226
15.8 Lernziele zu Kapitel 15 ............................................................................ 233
16 Graphen, Rekursion, Binärbäume .................................................................. 235
16.1 Graphen ..................................................................................................... 235
16.2 Rekursion .................................................................................................. 243
16.3 Binärbäume ............................................................................................... 248
16.4 Lernziele zu Kapitel 16 ............................................................................ 258
Sachwortverzeichnis .................................................................................................. 259