JavaTutorium

Tutorium zu Jetzt lerne ich Android 4-Programmierung ISBN 978-3-8272-4818-3

Inhalt Seite 1

Inhalt 1 Willkommen beim Java-Schnellkurs ...................................................... 82 Technik der Programmerstellung .......................................................... 11

2.1 Compiler und Interpreter ............................................................... 112.2 Die Java-Laufzeitumgebung JRE .................................................. 142.3 Programmerstellung mit dem JDK ............................................... 142.4 bung 1: HalloWelt - das erste Java-Programm ........................... 19

3 Einfhrung fr Programmieranfnger ................................................... 263.1 Einleitung ...................................................................................... 263.2 Vom Maschinencode zu den hheren Programmiersprachen ....... 28

3.2.1 Assembler ............................................................................. 293.2.2 Das Variablenkonzept ........................................................... 293.2.3 Die hheren Programmiersprachen ....................................... 313.2.4 Kontrollstrukturen ................................................................. 34

3.3 Die strukturierte Programmierung ................................................ 393.3.1 Typisierung ........................................................................... 393.3.2 Funktionen ............................................................................ 46

3.4 Die objektorientierte Programmierung ......................................... 513.4.1 Selbst definierte Datentypen ................................................. 513.4.2 Objektorientierte Problemlsung .......................................... 583.4.3 Objektorientierte Programmierung in Java ........................... 60

3.5 Noch Fragen? ................................................................................ 704 Anwendungsgrundgerst und Standardbibliothek ................................ 71

4.1 Kommentare .................................................................................. 724.2 Pakete und Import-Anweisung ...................................................... 74


Inhalt Seite 2

4.2.1 Ordnung schaffen mit Paketen .............................................. 744.2.2 Klassen aus Paketen verwenden ............................................ 754.2.3 Eigene Pakete ........................................................................ 76

4.3 Klassen .......................................................................................... 784.4 Eintrittspunkt ................................................................................. 80

4.4.1 Der Java-Eintrittspunkt: main() ............................................. 814.4.2 Der Android-Eintrittspunkt: onCreate() ................................ 83

4.5 Ein- und Ausgabe .......................................................................... 844.5.1 Text (Strings) ausgeben ......................................................... 854.5.2 Zahlen und andere Daten ausgeben ....................................... 864.5.3 Text einlesen ......................................................................... 904.5.4 Zahlen einlesen ...................................................................... 91

4.6 Namensgebung .............................................................................. 924.7 Stil ................................................................................................. 934.8 bung 2: Daten einlesen und ausgeben ........................................ 94

5 Praxisteil: Variablen und Konstanten .................................................. 1005.1 Konstanten .................................................................................. 100

5.1.1 Literale ................................................................................ 1005.1.2 Konstanten........................................................................... 102

5.2 Variablen ..................................................................................... 1025.2.1 Variablendefinition.............................................................. 1025.2.2 Werte in Variablen speichern .............................................. 1055.2.3 Initialisierung ...................................................................... 1055.2.4 Werte von Variablen abfragen ............................................ 1065.2.5 Gltigkeitsbereiche.............................................................. 107

5.3 Datentypen .................................................................................. 1085.3.1 Die elementaren Datentypen ............................................... 109


Inhalt Seite 3

5.3.2 Die komplexen Datentypen ................................................. 1115.3.3 Klassen ................................................................................ 1135.3.4 Interfaces (Schnittstellen) ................................................... 1185.3.5 Arrays.................................................................................. 1195.3.6 Aufzhlungen ...................................................................... 1215.3.7 Strings ................................................................................. 122

5.4 Typumwandlung ......................................................................... 1245.4.1 Automatische oder implizite (widening) Typumwandlungen 1245.4.2 Explizite (narrowing) Typumwandlungen ...................... 1255.4.3 Selbst definierte Typumwandlungen ................................... 125

5.5 Wrapper-Klassen ........................................................................ 1265.6 Quiz ............................................................................................. 128

6 Praxisteil: Operatoren ......................................................................... 1326.1 Die Operatoren ............................................................................ 132

6.1.1 Allgemeines ........................................................................ 1326.1.2 Arithmetische Operatoren ................................................... 1356.1.3 Zuweisungen ....................................................................... 1366.1.4 Inkrement und Dekrement .................................................. 1366.1.5 Die Vergleichsoperatoren ................................................... 1376.1.6 Die logischen Operatoren .................................................... 1406.1.7 Operatorhnliche Symbole .................................................. 143

6.2 Mathematische Funktionen ......................................................... 1436.2.1 Wichtige Methoden der Klasse Math .................................. 144

6.3 Strings (Zeichenketten) ............................................................... 1466.3.1 String-Literale ..................................................................... 1466.3.2 String-Variablen .................................................................. 148


Inhalt Seite 4

6.3.3 Konkatenation ..................................................................... 1496.3.4 Vergleiche mit == und != und String-Pooling ..................... 1496.3.5 Wichtige Methoden der Klasse String ................................. 151

6.4 bung 3: Berechnungen durchfhren ......................................... 1537 Praxisteil: Kontrollstrukturen .............................................................. 159

7.1 Verzweigungen ........................................................................... 1607.1.1 Die if-Konstruktion ............................................................. 1607.1.2 Die if-else-Konstruktion ...................................................... 1627.1.3 Die switch-Konstruktion ..................................................... 163

7.2 bung 4: Benutzereingaben prfen ............................................. 1657.3 Schleifen ...................................................................................... 168

7.3.1 Die while-Schleife ............................................................... 1697.3.2 Die do-while-Schleife ......................................................... 1727.3.3 Die for-Schleife ................................................................... 1727.3.4 Abbruchbefehle ................................................................... 174

7.4 bung 5: Daten filtern ................................................................ 1748 Praxisteil: Klassen ............................................................................... 178

8.1 Eine Vektor-Klasse ..................................................................... 1788.1.1 Zweidimensionale Vektoren ................................................ 1788.1.2 Die Klassendefinition .......................................................... 180

8.2 Felder .......................................................................................... 1828.2.1 Gltigkeitsbereich ............................................................... 1828.2.2 Zugriff von auerhalb der Klasse ........................................ 1838.2.3 Statische Felder ................................................................... 1868.2.4 Weiterfhrung des Beispiels ............................................... 187

8.3 Methoden .................................................................................... 1888.3.1 Aufbau von Methodendefinitionen ..................................... 189


Inhalt Seite 5

8.3.2 Parameter ............................................................................ 1918.3.3 Rckgabewerte .................................................................... 1958.3.4 this ....................................................................................... 1998.3.5 berladung .......................................................................... 2008.3.6 Weiterfhrung des Beispiels ............................................... 201

8.4 Der Konstruktor .......................................................................... 2028.5 Zugriffschutz ............................................................................... 2068.6 bung 6: Body Mass Index-Klasse............................................. 210

9 Praxisteil: Vererbung .......................................................................... 2149.1 Syntax ......................................................................................... 2159.2 Besonderheiten geerbter Elemente .............................................. 218

9.2.1 Basisklassenelemente bilden ein Unterobjekt ..................... 2189.2.2 Der Zugriffsspezifizierer protected ..................................... 2209.2.3 Aufruf des Basisklassenkonstruktors .................................. 221

9.3 berschreibung ........................................................................... 2239.4 Die Klasse Object ....................................................................... 2249.5 bung 7: toString() berschreiben .............................................. 2269.6 Polymorphie ................................................................................ 228

9.6.1 Dynamische Bindung .......................................................... 2309.6.2 Typidentifizierung zur Laufzeit .......................................... 233

10 Exkurs: Collections ......................................................................... 23510.1 Allgemeines ................................................................................ 23510.2 Container anlegen ....................................................................... 23610.3 Objekte ablegen und auslesen ..................................................... 23710.4 Container-Auswahl ..................................................................... 23710.5 Iteratoren ..................................................................................... 23810.6 Suchen und Sortieren in Containern ........................................... 240


Inhalt Seite 6

11 Exkurs: Schnittstellen ...................................................................... 24211.1 Abstrakte Methoden und Klassen................................................ 24211.2 Interfaces ..................................................................................... 243

11.2.1 Interfaces und Polymorphie................................................. 24311.2.2 Interfaces als Vertrge ......................................................... 24411.2.3 Interfaces definieren ............................................................ 24611.2.4 Interfaces implementieren ................................................... 247

12 Exkurs: Ausnahmen ........................................................................ 24912.1 Schema einer Exception-Behandlung ......................................... 24912.2 Exceptions auslsen .................................................................... 25112.3 Exceptions abfangen ................................................................... 25312.4 Exceptions und Methodendeklaration ......................................... 25512.5 Exception-Klassen ....................................................................... 25612.6 finally-Klausel ............................................................................. 257

13 Exkurs: Anonyme Objekte .............................................................. 26014 Exkurs: Innere Klassen ................................................................... 261

14.1 Innere Klassen ............................................................................. 26114.2 Lokale Klassen ............................................................................ 26114.3 Anonyme Klassen ....................................................................... 262

15 Exkurs: Threads .............................................................................. 26315.1 Die Klasse Thread ....................................................................... 263

15.1.1 Threads erzeugen ................................................................ 26315.2 Das Runnable-Interface ............................................................... 26715.3 Thread-Synchronisierung ............................................................ 267

16 Exkurs: Ereignis-Listener ................................................................ 27017 Exkurs: Java Generics ..................................................................... 274

17.1 Syntax ......................................................................................... 275


Inhalt Seite 7

17.1.1 Generische Klassen ............................................................. 27517.1.2 Generische Interfaces .......................................................... 27617.1.3 Generische Methoden ......................................................... 27617.1.4 Eingeschrnkte Platzhalter .................................................. 277

17.2 Parameter und Variablen von generischen Typen ....................... 27718 Exkurs: Zufallszahlen ..................................................................... 28019 Ein- und Ausgabe ............................................................................ 281

19.1 Dateien ........................................................................................ 28119.1.1 File ...................................................................................... 281

19.2 Ein- und Ausgabestrme (Streams) ............................................ 28319.3 Byteorientierte Dateiein-/ausgabe ............................................... 284

19.3.1 FileInputStream/FileOutputStream ..................................... 28419.3.2 BufferedInputStream/BufferedOutputStream ..................... 286

19.4 Zeichenorientierte Ein-/Ausgabe ................................................ 28719.4.1 FileReader/FileWriter ......................................................... 28719.4.2 InputStreamReader/OutputStreamWriter ............................ 28819.4.3 BufferedReader/BufferedWriter ......................................... 289

20 Schlsselwrter ............................................................................... 291Stichwortverzeichnis ................................................................................... 292


Willkommen beim Java-Schnellkurs Seite 8

1 Willkommen beim Java-Schnellkurs Dieser Kurs wurde als Begleitmaterial zu dem Buch Jetzt lerne ich Android konzipiert und richtet sich an

Leser mit grundlegenden Java-Kenntnissen, die dieses Wissen vertiefen und ausbauen mchten,

Umsteiger von anderen Programmiersprachen, die sich mit den Java-typischen Konzepten und Syntaxformen vertraut machen mchten, und

gegebenenfalls sogar absolute Anfnger, die mit diesem Tutorium den Einstieg in die Programmierung wagen mchten.

Sie knnen diesen Kurs vorab durcharbeiten oder und diese Vorgehensweise wrden wir Ihnen empfehlen parallel zu dem Buch Jetzt lerne ich Android lesen. Das Android-Buch enthlt dazu in den Text eingestreute Hinweise, wann Sie welche Tutorien (Kapitel) dieses Kurses durcharbeiten sollten.

Der Kurs selbst gliedert sich in drei grere Abschnitte:

einem ausfhrlichen Grundlagenteil dieser fhrt Sie in die wichtigsten Programmierkonzepte moderner objektorientierter Programmiersprachen ein, erlutert die Technik der Erstellung und Ausfhrung von Java-Programmen und stellt Ihnen verschiedene Anwendungsgerste vor.

Der Grundlagenteil umfasst die Tutorien 2 bis 4.

einem Praxisteil hier lesen Sie, wie die in Tutorium 3 vorgestellten Programmierkonzepte in der Sprache Java umgesetzt sind, und erhalten Gelegenheit, das Gelernte in bungen umzusetzen.

Der Praxisteil umfasst die Tutorien 5 bis 9 und sollte mglichst in einem Zug durchgearbeitet werden.

einem Exkursteil dieser umfasst diverse Tutorien zu ausgesuchten, fortgeschrittenen Themen.



Ziel des Kurses ist es, dem Leser so viele Java-Kenntnisse zu vermitteln, dass er a) den Erluterungen im Buch Jetzt lerne ich Android folgen kann und b) eine gute Basis fr weiterfhrende Java-Studien erhlt.

Der Kurs legt zu diesem Zweck viel Wert auf die verstndliche Vermittlung zentraler Programmierkonzepte (siehe hierzu auch Tutorium 3, das mit besonderem Augenmerk auf diejenigen Leser geschrieben wurde, die noch keine Programmiererfahrung haben oder zumindest noch nie mit einer hheren, objektorientierten Programmiersprache gearbeitet haben) ...

... sowie auf die Vorstellung der wichtigsten Java-Syntaxformen, beginnend mit Tutorium 4.

Der Kurs ist eine zustzliche Hilfe, die wir allen Android-Interessierten zur Verfgung stellen, um sich die ntigen Java-Grundkenntnisse zu erarbeiten. Er kann aber natrlich nicht die gleiche Qualitt oder die gleiche Leserspezifizitt haben, wie ein eigenes Lehrbuch, das zudem speziell auf die Bedrfnisse eines bestimmten Leserkreises zugeschnitten ist, wie z.B.:

Das Java-Easy-Buch aus dem Markt+Technik-Verlag Ideal fr den blutigen Programmieranfnger. Mit leicht und sicher nachzuvollziehenden Schritt-fr-Schritt-Anleitungen. Ein Buch, mit dem jeder den Einstieg in die Java-Programmierung schaffen kann.

Das Jetzt lerne ich Java-Buch aus dem Markt+Technik-Verlag Zur Wiederholung, Vertiefung und Fortbildung. Leicht verstndlich, mit Spa am Programmieren, aber ohne Anspruch auf Vollstndigkeit. Eines der erfolgreichsten Java-Einsteigerbcher auf dem deutschen Markt.

Das Fromzero2hero Java-Buch aus dem Markt+Technik-Verlag Gleicher Anspruch wie das Jetzt lerne ich, aber in etwas flippigerer, visuell orientierter Aufmachung.

Das Java Kompendium aus dem Markt+Technik-Verlag Umfassendes Standardwerk zur Java-Programmierung.

Die Bereitstellung eines passenden Java-Kurses als Begleitmaterial zu einem anderen Einsteigertitel ist auch fr uns ein Novum. Wir wrden uns daher freuen, wenn Sie uns mitteilen wrden, wie Sie mit dem Kurs bzw. der parallelen Einarbeitung in Java und die Android-Programmierung zurechtgekommen sind, ob der Kurs eher ausfhrlicher oder stringenter sein sollte und was wir vielleicht noch ansonsten verbessern knnten. Unsere Mail-Adresse: [email protected].

Icon HINWEIS


Technik der Programmerstellung Seite 11

2 Technik der Programmerstellung In diesem Tutorium wollen wir klren, wie aus einem Java-Quelltext ein ausfhrbares Java-Programm wird. Sie werden lernen, was es mit den Java-Hilfsprogrammen javac und java auf sich hat, was sich hinter den Begriffen Compiler, Linker und Virtual Machine verbirgt und wie Sie mithilfe des JDKs oder auch Eclipse Java-Programme erstellen.

2.1 Compiler und Interpreter Vor vielen, vielen Jahren, als Arbeitspeicher noch in Kbyte gemessen wurde und Java eine kaum bekannte Insel war, da verstanden die Menschen noch die Sprache der ... nein, nicht die Sprache der Tiere ist gemeint, sondern die Sprache der Prozessoren.

Der Prozessor ist das Herz eines jeden Rechners. Er ist es, der die Programme ausfhrt. Der Prozessor ist sehr schnell, aber er besitzt wenig Intelligenz. Er ist eine Maschine, die stur die Befehle abarbeitet, die an ihn geschickt werden. Ein Programm ist demnach nichts anderes als eine Folge solcher Befehle.

Der Prozessor kann allerdings nur Befehle verarbeiten, die er kennt. Die Summe dieser Befehle wird auch als Befehlssatz bezeichnet. Zudem mssen die Befehle als Bitfolgen codiert sein, denn der Prozessor als digitaler Baustein kann eben nur Bitinformationen (Null oder Eins, sprich: Spannung liegt an, Spannung liegt nicht an) verarbeiten.

Frher mussten Programmierer ihre Programme direkt mithilfe der Befehle aus dem Befehlssatz des Prozessors schreiben. Dies war natrlich sehr mhselig und so fand man schnell einen Weg, sich die Programmierarbeit zu erleichtern: Man verfasste die Programme zuerst als reine Quelltexte in einer speziellen Programmiersprache. Dann lie man diese Quelltexte in einem zweiten Schritt von einem passenden bersetzungsprogramm in ein ausfhrbares Programm (sprich eine Folge von binren Maschinenbefehlen) bersetzen.

Seither wurden Tausende von Programmiersprachen entwickelt und fr jede dieser Sprachen gibt es passende bersetzerprogramme. Diese



bersetzerprogramme zerfallen grundstzlich in zwei Kategorien: Compiler und Interpreter.



Compiler arbeiten, wie man es vom Beruf der bersetzer her kennt. Man bergibt dem Compiler den Quelltext und erhlt als Ergebnis das komplett bersetzte Programm, das anschlieend jederzeit ausgefhrt werden kann.

Interpreter arbeiten eher wie Dolmetscher. Sie werden zwischengeschaltet, wenn das Programm ausgefhrt werden soll. Dann lesen sie das Programm, das nur als Quelltext vorliegt, blockweise ein, bersetzen den aktuellen Block und lassen ihn vom Prozessor ausfhren.

Beide Anstze haben ihre Vor- und Nachteile, auf die wir hier jedoch nicht weiter eingehen. Wichtiger ist fr uns, dass Java das Beste aus beiden Welten verbindet, d.h. Java-Programme werden zuerst compiliert und dann interpretiert.

Rechner des Programmierers

00100001110110100110

Prozessor

Rechner des Anwenders

Interpreter

00111100111001011001

Compiler

00100001110110100110

Prozessor

Rechner des Anwenders

Interpreter

Abbildung 2.1: Kompilierung und Ausfhrung eines Java-Programms

Zuerst wird auf dem Rechner des Programmierers der Java-Quelltext in Abbildung 2.1 symbolisiert durch das Blatt ganz links mit den Schriftlinien mithilfe des Java-Compilers javac in binren Code bersetzt. Dieser Code ist allerdings noch kein echter Maschinencode, denn er basiert auf einem mehr oder weniger fiktiven Befehlssatz, den sich die Entwickler von Java ausgedacht haben. Wir nennen diesen Code daher auch den Bytecode (als Abgrenzung zu dem prozessorspezifischen Maschinencode).

Das als Bytecode vorliegende Programm kann dann an Freunde, Kunden oder wen auch immer weitergegeben und auf den Rechnern dieser Anwender ausgefhrt werden vorausgesetzt es ist auf dem Rechner ein Java-Interpreter installiert. Der wird dann zusammen mit dem Programm gestartet,



bersetzt den Bytecode in den Maschinencode des aktuellen Rechners und lsst ihn sogleich ausfhren.

2.2 Die Java-Laufzeitumgebung JRE Es wurde im vorangehenden Abschnitt schon angedeutet: Damit ein Java-Programm auf einem Rechner ausgefhrt werden kann, muss auf diesem Rechner ein Java-Interpreter installiert sein.

Wirklich nur ein Interpreter? Wie so oft sind die wahren Verhltnisse komplizierter, als es zuerst den Anschein hat. Der Java-Interpreter bernimmt nmlich nicht nur die Aufgabe, den Bytecode blockweise zu lesen und zu bersetzen. Vielmehr simuliert er einen (nahezu) kompletten virtuellen Rechner und fhrt das Programm quasi auf diesem Rechner aus. Man spricht daher auch von der Java Virtual Machine. Alles, was zur Erzeugung dieser virtuellen Maschine ntig ist, inklusive dem eigentlichen Interpreter, der Java-Standardbibliothek (einer Sammlung grundlegender Klassen (Code-Bausteine), die jeder Java-Programmierer beim Schreiben eigener Programme verwenden kann) sowie Browser-Plugin und anderer Hilfsprogramme, bildet zusammen die sogenannte Java-Laufzeitumgebung (Java Runtime Environment, kurz JRE).

Die JRE gibt es fr eine Vielzahl von Plattformen und kann kostenlos von der Oracle-Website http://www.oracle.com/technetwork/java/javase/downloads/index.html heruntergeladen werden. Eine aktuelle Version ist auch im JDK enthalten.

2.3 Programmerstellung mit dem JDK In Java knnen Sie die verschiedensten Arten von Programmen schreiben. Die drei wichtigsten Grundtypen sind

Konsolenanwendungen, GUI-Anwendungen und Applets. Zum Einstieg in die Java-Programmierung konzentrieren wir uns ganz auf die Konsolenanwendungen.



Konsolenanwendungen Konsolenanwendungen sind unserer Meinung nach zu Unrecht die Stiefkinder der modernen Software-Entwicklung. Ohne Fenster und ohne grafische Benutzeroberflche fristen sie in der bunten Welt der Window-Manager ein kmmerliches Nischendasein. Viele PC-Benutzer, insbesondere aus der Microsoft-Windows-Gemeinde, wissen nicht einmal mehr, was eine Konsole ist und wie man mit ihr arbeitet. Die Schuld daran trgt nicht allein der Zeitgeist, sondern auch die Microsoft-Betriebssystemdesigner haben dazu beigetragen, die nachdem sie zu einer Zeit, als Mac- und UNIX-Benutzer schon lngst von leistungsfhigen Window-Managern profitierten, ihre Anhnger mit mittelmigen Surrogaten wie Windows 3.1 oder Windows 95 qulten nunmehr dazu bergegangen sind, die Erinnerung an MS-DOS zu lschen und die Konsole (unter Windows meist Eingabeaufforderung oder MS-DOS-Eingabeaufforderung tituliert) immer geschickter vor den Augen der Anwender zu verbergen.

Dabei haben Konsolenanwendungen durchaus ihre Vorzge: Die Programme sind klein und schlank, schnell in der Ausfhrung und sofern man einigermaen mit der Arbeit auf der Konsole vertraut ist gut zu bedienen. Sie eignen sich vorzglich als Lehr- und bungsbeispiele zum Einstieg in die Programmierung (weswegen es sich bei den Beispielprogrammen aus den ersten Teilen dieses Buches fast ausnahmslos um Konsolenanwendungen handelt), werden aber auch weiterhin in der professionellen Software-Entwicklung eingesetzt beispielsweise fr Webserver-Software (gelegentlich ergnzt um fensterbasierte Konfigurationsprogramme), Tools fr Systemadministratoren oder eben fr Entwickler (siehe die JDK-Hilfsprogramme).

Eine kurze Einfhrung in die Bedienung der Konsole finden Sie auf www.carpelibrum.de.

Ein einfaches Konsolen-Grundgerst Viele Programmierlehrbcher beginnen mit einem kleinen Programm, das die Meldung Hello World auf den Bildschirm ausgibt. Wir wollen uns dieser Tradition anschlieen und eine Konsolenanwendung erzeugen, die sich mit einem freudigen Hallo Welt meldet. public class HalloWelt { public static void main(String[] args) {

Icon REF



System.out.println("Hallo Welt!"); } } Was dieser Code bedeutet und wie er aufgebaut ist, soll uns im Moment noch nicht interessieren. Worum es uns geht, ist, wie wir diesen Quelltext erstellen, bersetzen und ausfhren knnen.

Konsolenanwendungen erstellen und ausfhren Um Konsolenanwendungen auf Ihrem Computer zu erstellen und auszufhren, gehen Sie folgendermaen vor:

1. Rufen Sie einen beliebigen Texteditor auf, mit dem Sie Ihren Quelltext als reinen, unformatierten Text abspeichern knnen. Unter Windows eignet sich beispielsweise der Notepad-Editor, den Sie ber das Start-Men mit START/PROGRAMME/ZUBEHR/EDITOR aufrufen knnen. Alternativ knnen Sie das Start-Men ffnen und unten in das Suchfeld den Begriff notepad eingeben.

Komfortabler als der Windows-eigene Notepad-Editor ist der Editor Notepad++, den Sie von der Webseite http://sourceforge.net/projects/notepad-plus herunterladen knnen.

Unter Linux knnen Sie z.B. den vi, KEdit oder KWrite verwenden.

2. Legen Sie in Ihrem Editor eine neue Datei an (blicherweise Menbefehl DATEI/NEU), tippen Sie obigen Quelltext ein und speichern Sie die Datei unter dem Namen HalloWelt.java. Wichtig ist dabei, dass die Quelltextdatei exakt den gleichen Namen trgt wie die in dem Quelltext definierte Klasse (hier also class HalloWelt), wobei auch die Gro- und Kleinschreibung zu beachten ist. Weiterhin wichtig ist, dass die Datei die Dateiendung .java trgt!

Bei Verwendung von Notepad unter Windows XP gibt es manchmal Probleme, weil der Notepad-Editor die Dateiendung .txt anhngt (aus HalloWelt.java wird dann HalloWelt.java.txt). Um dies zu vermeiden, gibt es zwei Mglichkeiten. Die erste Lsung besteht darin, den kompletten Dateinamen, samt Extension, in Anfhrungszeichen zu setzen: "HalloWelt.java". Die zweite Mglichkeit ist, die Extension .java im Windows Explorer zu registrieren. Speichern Sie dazu nach Methode 1 eine Datei mit der Extension .java. Wechseln Sie danach in den Windows

Icon REF



Explorer und doppelklicken Sie auf die Datei. Ist die Extension noch nicht registriert, erscheint jetzt der FFNEN MIT-Dialog. Whlen Sie als gewnschtes Bearbeitungsprogramm Notepad aus und aktivieren Sie die Option DIESE DATEI IMMER MIT DIESEM PROGRAMM FFNEN. Wenn Sie den Dialog jetzt abschicken, wird die Extension .java registriert und mit Notepad als Standardverarbeitungsprogramm verknpft. Danach knnen Sie .java-Dateien per Doppelklick in Notepad laden und werden nie wieder rger mit an Java-Dateien angehngte .txt-Extensionen haben.

3. Kompilieren Sie den Quelltext, indem Sie den Java-Compiler javac aufrufen und beim Aufruf den Namen der zu kompilierenden Quelltextdatei bergeben. ffnen Sie dazu ein Konsolenfenster und wechseln Sie in diesem zum Verzeichnis Ihrer Java-Quelldatei.

Im Gegensatz zu Linux-Anwendern sind viele Windows-Anwender heutzutage gar nicht mehr mit dem Umgang der Konsole vertraut. Unter Windows heit die Konsole Eingabeaufforderung oder MS-DOS-Eingabeaufforderung und wird ber das Start-Men aufgerufen (START/PROGRAMME/ oder START/PROGRAMME/ZUBEHR). In der Konsole mssen Sie nun mithilfe des cd-Befehls in das Verzeichnis wechseln, in dem Sie die Datei HalloWelt.java abgespeichert haben. Nehmen wir an, es war das Verzeichnis c:\Beispiele. Dann tippen Sie hinter dem Prompt der Konsole den Befehl cd c:\Beispiele ein und schicken ihn durch Drcken der (Enter)-Taste ab.

Danach tippen Sie zum Kompilieren folgenden Befehl ein:

javac HalloWelt.java Schicken Sie den Befehl durch Drcken der (Enter)-Taste ab.

Hat sich kein Tippfehler eingeschlichen, wird als Ergebnis eine ausfhrbare Bytecode-Datei mit der Extension .class erzeugt in unserem Beispiel also HalloWelt.class.

Sollten Sie beim Abschicken des Befehls eine Meldung in der Form Befehl oder Dateiname nicht gefunden erhalten, ist Ihr System nicht so eingerichtet, dass Sie die Java-Entwicklungsprogramme aus jedem beliebigen Verzeichnis aufrufen knnen. Lesen Sie dann bitte noch einmal in dem Buch

Icon STOPP

Icon STOPP



Jetzt lerne ich Android den Abschnitt 1.2.2 zur Eintragung des JDK in den Systempfad.

Wenn Sie irgendwann anfangen, den Quelltext des Programms auf mehrere Klassen/Dateien zu verteilen, bergeben Sie dem Compiler beim Aufruf eine Liste der Dateinamen oder wenn alle Dateien zusammen in einem Verzeichnis stehen einfach *.java.

4. Lassen Sie die fertige Anwendung ausfhren. Dazu rufen Sie den Java-Interpreter (java) auf und bergeben diesem als Parameter den Namen Ihrer kompilierten Bytecode-Datei, aber ohne die Endung .class: java HalloWelt Sollten Sie daraufhin eine Fehlermeldung der Form Exception in thread "main" java.lang.NoClassDefFoundError: HalloWelt erhalten, bedeutet dies, dass der Interpreter die gewnschte Java-Klasse nicht findet. Dies kann daran liegen, dass die .class-Datei nicht erzeugt wurde (kontrollieren Sie nach dem Kompilieren mithilfe des Befehls dir, ob die Datei HalloWelt.class im Verzeichnis angelegt wurde). Mglich ist auch, dass Sie den Klassennamen nicht exakt so eingegeben haben, wie er im Quelltext definiert ist (auf gleiche Gro- und Kleinschreibung achten). Manchmal liegt es aber auch daran, dass irgendeines der auf Ihrem System installierten Programme die Java-Umgebungsvariable CLASSPATH so gesetzt hat, dass die Class-Dateien im aktuellen Verzeichnis nicht mehr gefunden werden. Dann mssen Sie die CLASSPATH-Variable bearbeiten und um den Platzhalter fr das aktuelle Verzeichnis (;.) erweitern.

Klassenpfad

Java-Programme bestehen aus Klassen. Diese sind in Quelltextdateien (Extension .java) oder als Bytecode in .class-Dateien (Extension .class) definiert. Wenn Sie ein Java-Programm kompilieren oder ausfhren, suchen sich die zustndigen Java-Hilfsprogramme (Compiler oder Interpreter) zu allen im Programm verwendeten Klassen die zugehrigen Quelltext- oder .class-Dateien zusammen.

Icon AUFSTEIGER



Standardmig wird im aktuellen Arbeitsverzeichnis (also von dem aus z.B. der Interpreter aufgerufen worden ist) und in den Class-Archiven .jar im LIB-Verzeichnis der JDK-Installation gesucht.

Solange Sie fr jedes Programm ein eigenes Verzeichnis anlegen und die Quelltextdateien des Programms zusammen in diesem Verzeichnis speichern, gestaltet sich die Programmerstellung und -ausfhrung recht einfach.

Probleme gibt es meist nur dann, wenn irgendein anderes Programm bei der Installation die CLASSPATH-Variable gesetzt hat. Dann suchen die JDK-Programme nmlich nicht mehr im aktuellen Verzeichnis es sei denn, das aktuelle Verzeichnis symbolisiert durch einen Punkt (.) wurde explizit in der Umgebungsvariablen mit aufgefhrt. Meist ist dies aber nicht der Fall, sodass Sie den Eintrag fr das aktuelle Verzeichnis selbst anhngen mssen.

alter Eintrag: SET CLASSPATH=C:\programme\aerger neuer Eintrag: SET CLASSPATH=C:\programme\aerger;. Windows XP/Vista/7: Bearbeiten Sie die CLASSPATH-

Umgebungsvariable im Dialogfeld der Systemeigenschaften (analog zu der im Buch Jetzt lerne ich Android beschriebenen Einrichtung der PATH-Variablen).

Linux: Setzen oder passen Sie die CLASSPATH-Variable in .login, .profile, .tcshrc, .bashrc o.. an (analog zu der im Buch Jetzt lerne ich Android beschriebenen Einrichtung der PATH-Variablen). Fr csh beispielsweise:

setenv CLASSPATH /bin/aerger;.

2.4 bung 1: HalloWelt - das erste Java-Programm Aufgabenstellung

Schreiben Sie ein Programm mit der Klasse HalloName, wobei Sie Name durch Ihren Vornamen ersetzen. ndern Sie auch den Text, den das Programm bei der Ausfhrung ausgibt, sodass Sie persnlich gegrt werden. Kompilieren Sie das Programm und fhren Sie es aus.



Versuchen Sie die Aufgabe zuerst selbststndig zu lsen. Wenn Sie nicht weiter wissen und Hilfe bentigen, lesen Sie die Lsung.

Lesen Sie den Lsungsabschnitt aber auch dann durch, wenn Sie die bung selbststndig bearbeiten knnen. Wir haben auf dem beschriebenen Lsungsweg absichtlich ein paar lehrreiche Fehltritte eingebaut.

Lsung

1. ffnen Sie Ihren Editor.

2. Tippen Sie zunchst den ursprnglichen Quelltext ein.

3. Speichern Sie die Datei unter dem Namen HalloWelt.java.

Bitte die Datei nicht schlieen. Wir werden Sie gleich weiter bearbeiten.



4. Kontrollieren Sie, dass in der Titelleiste der korrekte Dateiname

angezeigt wird. Falls Ihr Editor den Dateinamen nicht in der Titelleiste anzeigt, ffnen Sie den Windows Explorer und lassen Sie sich den Inhalt des Verzeichnisses anzeigen, in dem Sie die Datei gespeichert haben.

5. ffnen Sie ein Konsolenfenster.

6. Wechseln Sie in das Verzeichnis, in der die Java-Quelltextdatei gespeichert ist.

7. Kompilieren Sie die Datei mit dem Befehl javac HalloWelt.java. Kontrollieren Sie mithilfe des dir-Befehls, ob die Class-Datei erzeugt wurde.



Wenn Sie nach Aufruf des Compilers javac Fehlermeldungen erhalten, vergleichen Sie noch einmal den Quelltext im Editor mit dem oben abgedruckten Code. Vermutlich haben sich Tippfehler eingeschlichen. Beachten Sie auch die Gro- und Kleinschreibung, die bei Java sehr wichtig ist. Lesen Sie die Fehlermeldungen des Compilers. Oft enthalten die Fehlermeldungen nhere Angaben zu der Art des Fehlers oder der Zeile, wo der Fehler ungefhr auftrat.

Java unterscheidet strikt zwischen Gro- und Kleinschreibung.

So weit, so gut! Als nchsten Schritt werden wir den Namen der Klasse ndern.

8. Wechseln Sie noch einmal in den Editor.

9. Ersetzen Sie im Klassennamen HalloWelt den Teil Welt durch Ihren Vornamen. Wenn Sie also z.B. Dirk heien, sollte die Klasse nun den Bezeichner HalloDirk tragen.

Icon STOPP

Icon MERKSATZ



10. Speichern Sie die Datei.

11. Kompilieren Sie die Datei.

Hoppla! Der Compiler beschwert sich, dass die Klasse HalloDirk nicht in einer Datei HalloDirk.java definiert ist.

Richtig. Wir haben ja vergessen, den Dateinamen zu ndern.

Ein Hinweis zur Codeorganisation. Sie knnen in einer Java-Quelltextdatei beliebig viele Klassen definieren. Aber nur eine dieser Klassen darf als public definiert sein. Gibt es eine public-Klasse, muss die Datei exakt genauso heien wie die Klasse.

12. Speichern Sie die Datei unter dem Namen der Klasse (Extension .java nicht vergessen).

Icon MERKSATZ




Sehr schn. Jetzt mssen wir nur noch die Ausgabe ndern.

Um zu sehen, was die Ausgabe des Programms ist, sollten Sie das Programm jetzt einmal ausfhren.

Aha, die Ausgabe ist die Textpassage, die im Quelltext in den Anfhrungszeichen steht.

Programmierer nennen so etwas einen String eine Zeichenfolge, die vom Programm verarbeitet sind. Um diese Zeichenfolgen von dem umliegenden Programmcode zu unterscheiden, werden sie blicherweise in Anfhrungszeichen gesetzt.

Icon MERKSATZ



14. ndern Sie den auszugebenden String in einen Gru, der an Sie gerichtet ist.

15. Speichern Sie die Datei.


17. Fhren Sie das Programm aus.

Aufgabe erfllt!


Einfhrung fr Programmieranfnger Seite 26

3 Einfhrung fr Programmieranfnger Dieses Tutorium, das wir aus dem Java-Kompendium bernommen haben, ist vor allem fr Leser gedacht, die noch berhaupt keine Erfahrung in der objektorientierten Programmierung haben, und fhrt anhand theoretischer Gedankenspiele und -modelle in die Grundprinzipien der Programmierung ein.

3.1 Einleitung Java ist eine wunderbare Programmiersprache. Sie ist modern, leistungsfhig, vielseitig, in gewisser Weise sogar sthetisch ... Eines ist sie jedoch ganz bestimmt nicht: leicht zu erlernen. Nun, das alleine wre ja noch gar nicht mal so schlimm schlielich erwartet ja niemand, dass eine so mchtige Sprache von einem Tag auf den anderen zu meistern wre. Whrend sich der hoffnungsvolle Novize jedoch in die meisten anderen Sprachen Schritt fr Schritt einarbeiten kann, muss er sich in Java gleich zu Beginn mit einer Vielzahl sehr komplizierter Konzepte auseinandersetzen.

So besteht bereits das einfachste Programm, das in Java geschrieben werden kann, aus mindestens vier Zeilen, vollgepackt mit kryptischem Code: public class Programm { public static void main(String[] args) { System.out.println("Hallo Anwender!"); } } Das gleiche Programm, das brigens nichts anderes macht, als den Benutzer mit einem freundlichen Hallo auf der Konsole zu begren, htte ein Basic-Programmierer Anfang der Neunziger wie folgt geschrieben: print "Hallo Anwender!" Die erste Hrde liegt fr den Java-Programmierer also extrem hoch, sodass ihm letzten Endes nur drei Mglichkeiten bleiben:



1. Er luft unter der Hrde durch, d.h., er akzeptiert die ihm nicht verstndlichen Syntaxformen des Grundgersts als gottgegeben und arbeitet sich danach so gut es geht schrittweise in die Sprache ein.



2. Er wartet mit dem Programmieren, bis er sich theoretisch so weit in die Sprache eingearbeitet hat, dass er smtliche im Grundgerst vorkommenden Konzepte verinnerlicht hat. Dann erst nimmt er die Hrde.

3. Er verzichtet auf jegliche Eleganz und klettert ber die Hrde. Den letzten Weg werden Sie jetzt einschlagen. Indem Sie in einem kurzen Abriss die historische Entwicklung der Programmiersprachen von den ersten Anfngen ber das alte Basic und C bis hin zu Java nachvollziehen, werden Sie sich mit den wichtigsten Konzepten moderner Programmiersprachen zumindest soweit vertraut machen, dass Sie das Grundgerst verstehen und einfache Programme schreiben knnen.

3.2 Vom Maschinencode zu den hheren Programmiersprachen Programmieren bedeutet, dem Rechner Befehle zu erteilen, die er ausfhren kann. Frher wurden diese Befehle vom Rechenwerk ausgefhrt, das in den ersten Rechenmaschinen aus dem 19. Jahrhundert noch mechanisch arbeitete. Heute ist das Herzstck des Rechners der Prozessor. Doch eines hat sich nicht gendert: Jeder Rechner/Prozessor verfgt nur ber einen ganz begrenzten Satz an Befehlen, und auch diese versteht er nur, wenn sie binr, d.h. als eine Folge von Nullen und Einsen, codiert vorliegen.1

1 Ein moderner Maschinenbefehl sieht vereinfacht etwa wie folgt aus: 10000011 1100000 00000011 10000011 ist der Befehlscode des Addieren-Befehls. Er weist den Prozessor an, den Wert des im ersten Operanden angegebenen Registers um den Wert des zweiten Operanden zu erhhen. Die Bitfolge 1100000 steht fr das Register EAX (Register sind einzelne, interne Speicherzellen des Prozessors, in denen er die zu verarbeitenden Daten, etwa aus dem Arbeitsspeicher geladene Daten, zwischenspeichern kann). Der zweite Operand ist eine einfache Ganzzahl, die 3, nur eben binr codiert im Dualsystem: 00000011. Der gesamte Befehl lautet demnach: Addiere zu dem aktuellen Wert des Registers EAX den Wert 3.



10100001 00111111101001100110010100000001 10000011 1100000 00000000000000000000000000000011 10100011 00111111101001100110010100000001

3.2.1 Assembler Da die Programmierung mit binr codierten Maschinenbefehlen uerst mhselig und fehleranfllig ist, sann man schon frh auf Mglichkeiten, die Programmierung zu vereinfachen. Ein erster Schritt in diese Richtung war Assembler.

Assembler-Programmierung ist immer noch Programmierung auf Maschinenebene, nur dass der Programmierer die Befehle nicht mehr binr codiert, sondern in Form sogenannter Mnemonics niederschreibt. MOV EAX, [3FA66501] ADD EAX, 3 MOV [3FA66501], EAX Ein spezielles bersetzerprogramm, das wie die Sprache ebenfalls Assembler genannt wird, bersetzt die Befehlsnamen (MOV, ADD ...), Registerbezeichnungen (EAX, EDX ...) Speicheradressen ([3FA66501] ) und Zahlen (3 ) in die zugehrigen Binrfolgen.

3.2.2 Das Variablenkonzept Einfache Zahlen knnen zumeist direkt in die Maschinenbefehle integriert und vom Prozessor verarbeitet werden (siehe den Befehl ADD EAX, 3). Fr komplexere Daten wie z.B. Zeichenfolgen (Dies ist ein Text) ist dies nicht mglich. Sie mssen im Arbeitsspeicher abgelegt und bei Bedarf in den Prozessor geladen werden.

Zeichenfolgen werden in der Programmierung gemeinhin als Strings bezeichnet.

Auch Daten, denen im Programm eine bestimmte Bedeutung zukommt und deren Wert sich im Laufe des Programms ndern kann, mssen im Arbeitsspeicher verwahrt werden. Ein Programm, das die Mausklicks des Anwenders zhlt, knnte beispielsweise einen bestimmten Bereich im Arbeitsspeicher fr die Anzahl der Mausklicks reservieren. Beim Programmstart schreibt es den Wert 0 in diesen Speicherbereich. Danach

1.



lauscht es auf Mausklicks, und jedes Mal, wenn der Anwender eine Maustaste drckt, liest es den aktuellen Wert des Speicherbereichs in den Prozessor, addiert den Wert 1 und schreibt das Ergebnis zurck in den Speicherbereich. So werden aus an sich bedeutungslosen Zahlenwerten sinnvolle Daten!

In den obigen Maschinenbefehlen wurden die Speicheradressen, von denen Daten geladen oder in die Daten geschrieben werden sollten, stets als explizite (hexadezimale oder binre) Adressen angegeben. Dies hat zwei gravierende Nachteile: Der Programmierer muss sich merken oder gesondert notieren, welche Daten an welchen Adressen stehen, und er ist selbst fr die korrekte Speicherbelegung verantwortlich, muss also beispielsweise aufpassen, dass sich die Speicherbereiche zweier Daten nicht berlappen.

0xEF01

0xEF02

0xEF03

0xEF04

0xEF05

50xEF01

0xEF02

0xEF04

0xEF05

0xEF03

0xEF01

0xEF02

0xEF04

0xEF05

0xEF03

0xEF03Preis

Preis

Abbildung 3.1: Variablen sind ein wenig wie Schubladen, in denen man Werte aufbewahren kann.

Hier bringt das Konzept der Variablen, das schnell auch in Assembler Einzug fand, Abhilfe. Statt numerischer Speicheradressen vergibt der Programmierer Namen und berlsst dem bersetzerprogramm (im Falle der Assembler-Programmierung also dem Assembler) die Zuordnung dieser Namen zu echten Speicheradressen. Statt nichts sagender Zahlen kann der Programmierer nun Namen auswhlen, die auf Art und Zweck der gespeicherten Daten hinweisen, beispielsweise mausklickZaehler, alter oder preis.



Das Beziehungsgefge aus Name, zugehrigem Speicherort und darin abgelegten Daten wird als Variable bezeichnet. Im alltglichen Sprachgebrauch wird die Variable aber auch hufig mit ihrem Wert, d.h. mit den in ihr abgelegten Daten, gleichgesetzt. Wenn ein Programmierer also davon spricht, dass er die Variable A zur Variablen B addiert, so meint er damit, dass der Wert in der Variablen A zu dem Wert der Variablen B hinzuaddiert wird.

3.2.3 Die hheren Programmiersprachen Ende der Fnfziger, Anfang der Sechziger wurden die ersten hheren Programmiersprachen entwickelt. Anders als die Assemblersprachen, bei denen jeder Befehl der Sprache exakt einem Maschinenbefehl entspricht, arbeiten die hheren Programmiersprachen mit Anweisungen, die weitaus komplexere Operationen ausfhren und in eine ganze Folge von Maschinenbefehlen bersetzt werden. Klar, dass es hierfr spezielle, entsprechend leistungsfhige bersetzerprogramme geben muss. Dabei wird je nach der prinzipiellen Arbeitsweise zwischen Compilern und Interpretern unterschieden:

Ein Compiler liest den gesamten Quelltext des Programms (oder Programmmoduls) ein, analysiert ihn und bersetzt ihn dann in Maschinencode. Dieser Maschinencode kann mithilfe eines weiteren Programms, des Linkers, mit anderem Maschinencode verbunden und in ein ausfhrbares Programm verwandelt werden (beispielsweise eine Windows-EXE-Datei). Zum Starten des Programms wird die ausfhrbare Programmdatei aufgerufen.

Ein Interpreter liest den Quelltext Zeile fr Zeile ein. Jede Zeile wird sofort bersetzt und direkt zur Ausfhrung an den Prozessor weitergereicht. Zum Ausfhren des Programms muss also nur der Quelltext des Programms an den Interpreter bergeben werden.

Fr jede hhere Programmiersprache gibt es einen eigenen Compiler oder Interpreter. Wortschatz und Grammatik der Programmiersprache sind in der Spezifikation der Sprache niedergeschrieben und im Compiler (oder Interpreter) implementiert. Die Sprache wird also genauso gut durch den Compiler (Interpreter) wie durch ihre Spezifikation definiert. Oder um es noch drastischer zu formulieren: Wenn Sie ein Programm geschrieben haben, das sich mit dem zugehrigen Compiler nicht bersetzen lsst, nutzt es Ihnen

Icon INFO



gar nichts, wenn Sie belegen knnen, dass Ihr Quelltext exakt den Regeln der Sprachspezifikation folgt. Letzte Instanz ist in so einem Fall der Compiler. Sie knnen sich bei dem Compiler-Hersteller beschweren, aber wenn Sie Ihr Programm bersetzen mchten, mssen Sie den Regeln folgen, die der Compiler implementiert2.

Die obige Unterscheidung zwischen Compiler und Interpreter beschreibt die traditionellen Grundprinzipien, die mit Kompilation und Interpretation verbunden sind. Obwohl diese Grundprinzipien nach wie vor gelten, knnen moderne Compiler und Interpreter in einzelnen Punkten davon abweichen. (Der Java-Compiler erzeugt beispielsweise weder echten Maschinencode noch ausfhrbare EXE-Dateien, sondern Bytecode, siehe Tutorium Technik der Programmerstellung.)

Ein einfaches Programm, das von der Konsole eine Radiusangabe einliest, den zugehrigen Kreisumfang berechnet und diesen auf die Konsole ausgibt, wrde in Basic geschrieben wie folgt aussehen: ' Programm zur Berechnung des Kreisumfangs print "Geben Sie einen Radius ein: " input radius umfang = 2 * 3.1415 * radius print "Der Kreisumfang betraegt " umfang Das Programm beginnt damit, dass es einen Text ausgibt, der den Anwender auffordert, ber die Tastatur einen Radiuswert einzutippen. Dieser wird mit dem Schlsselwort input in die Variable radius eingelesen. (Die Variable radius wird dabei automatisch eingerichtet und mit ausreichend Speicher verbunden.) In der vorletzten Quelltextzeile wird der Kreisumfang berechnet und in der neuen Variablen umfang abgespeichert. Schlielich gibt das Programm einen kurzen erluternden Text und den Inhalt von umfang auf die Konsole aus.

2 rgerlich ist es, wenn es zu einer Programmiersprache mehrere Compiler (bzw. Interpreter) gibt, die die Syntax und Grammatik der Sprache jeder fr sich ein wenig verndern oder eigenmchtig interpretieren. In so einem Fall schafft jeder dieser Compiler (Interpreter) einen eigenen, inkompatiblen Sprachdialekt (wie dies Microsoft beispielsweise mit der Einfhrung seines Visual J++-Compilers anstrebte).

Icon REF



Das Beispiel zeigt nicht nur, wie einfach die Programmierung in hheren Programmiersprachen sein kann; es demonstriert auch den Einsatz einiger wichtiger Elemente, die fr Quelltexte hherer Programmiersprachen typisch sind:

Kommentare, die den Quelltext erklren und vom Programmierer eingefgt werden, damit er selbst oder andere Programmierer sich spter schneller in den Quelltext einarbeiten knnen. Kommentare werden vom bersetzerprogramm ignoriert. (' Programm zur Berechnung des Kreisumfangs).

Konstante Werte, die in der Programmierung als Literale bezeichnet werden ("Geben Sie einen Radius ein! ", 2, 3.1415 ...). Beachten Sie, dass in Dezimalzahlen die Nachkommastellen durch einen Punkt und nicht wie im Deutschen blich durch ein Komma abgetrennt werden!

Variablen, zum Abspeichern und Verwalten der Daten (radius, umfang).

Operatoren, zur Durchfhrung einfacher, grundlegender Bearbeitungsschritte wie der Multiplikation (*) oder der Zuweisung eines berechneten Werts an eine Variable (=).

In der Sprache oder in den Standardbibliotheken der Sprache implementierte hhere Befehle, die hufig bentigte Aufgaben erledigen beispielsweise das Einlesen von Daten ber die Tastatur (input) oder die Ausgabe von Strings auf die Konsole (print).

Bildschirmausgaben und Konsolenanwendungen

Die meisten PC-Benutzer, vor allem Windows- oder KDE-Anwender, sind daran gewhnt, dass die Programme als Fenster auf dem Bildschirm erscheinen. Dies erfordert aber, dass das Programm mit dem Fenstermanager des Betriebssystems kommuniziert und spezielle Optionen und Funktionen des Betriebssystems nutzt. Programme, die ohne fensterbasierte, grafische Benutzeroberflche (GUI = graphical user interface) auskommen, knnen hierauf jedoch verzichten und stattdessen die Konsole zum Datenaustausch mit dem Benutzer verwenden.

Die Konsole ist eine spezielle Umgebung, die dem Programm vorgaukelt, es lebe in der guten alten Zeit, als es noch keine Window-Systeme gab und immer nur ein Programm zurzeit ausgefhrt werden konnte. Dieses



Programm konnte dann uneingeschrnkt ber alle Ressourcen des Rechners verfgen beispielsweise die Tastatur, das wichtigste Eingabegert, oder auch den Bildschirm, das wichtigste Ausgabegert. Der Bildschirm war in der Regel in den Textmodus geschaltet, wurde also nicht aus Pixelreihen, sondern aus Textzeilen aufgebaut.

Unter Windows heit die Konsole MS-DOS-Eingabeaufforderung oder auch nur Eingabeaufforderung und kann je nach Betriebssystem ber START/PROGRAMME oder START/PROGRAMME/ZUBEHR aufgerufen werden.

Konsolenprogramme werden meist von einem Konsolenfenster aus aufgerufen, d.h., am Eingabeprompt (Ende der untersten Textzeile der Konsole) wird der Name des Programms eingetippt und mit der (Enter)-Taste abgeschickt. Die Ausgaben des Programms erscheinen Zeile fr Zeile darunter (sind die Zeilen der Konsole vollgeschrieben, werden sie nach oben gescrollt). Eingaben ber die Tastatur werden in der aktuellen Zeile der Konsole angezeigt und nach Drcken der (Enter)-Taste an das Programm weitergeleitet.

Abbildung 3.2: Ausfhrung eines Java-Programms auf der Windows-Konsole

3.2.4 Kontrollstrukturen Maschinenbefehle werden grundstzlich der Reihe nach so wie sie in den Arbeitsspeicher geladen wurden oder wie der Interpreter sie an den Prozessor



schickt ausgefhrt. Wo es ntig oder opportun ist, von dieser sequenziellen Ausfhrung abzuweichen, kann der Programmierer Sprungbefehle einbauen, die dafr sorgen, dass die Programmausfhrung an einer beliebigen anderen Stelle des Programms fortgefhrt wird.

Hhere Programmiersprachen, auch Basic, geben die Fhigkeit Sprnge zu vollziehen meist auf verschiedene Weise an den Programmierer weiter:

durch direkte Sprnge zu beliebigen Anweisungen (das zugehrige Schlsselwort heit in der Regel goto)

durch spezielle Kontrollstrukturen, die der bersetzer mithilfe von Sprngen realisiert

durch Funktionsaufrufe (siehe Abschnitt Funktionen) Die direkten Sprnge mit goto sollen uns nicht weiter interessieren. Sie fhren schnell zu wirrem Spagetticode und werden in Java daher nicht untersttzt.

Wesentlich interessanter sind da schon die Kontrollstrukturen, zu denen

die bedingte Ausfhrung, die Verzweigung und die Schleife gehren.

Die bedingte Ausfhrung Eine bedingte Ausfhrung dient dazu zu entscheiden, ob eine nachfolgende Anweisung oder ein Anweisungsblock ausgefhrt werden soll oder nicht. In den meisten Programmiersprachen wird die bedingte Ausfhrung mit dem Schlsselwort if eingeleitet. In Basic hat sie folgenden Aufbau: if (Bedingung) then Anweisung(en) end if Diese Konstruktion kann man wie einen deutschen Konditionalsatz lesen:

Wenn die Bedingung erfllt ist, dann (und nur dann) fhre die Anweisungen aus.

Bei Ausfhrung des Programms wird zuerst die Bedingung ausgewertet. Die Bedingung ist dabei nichts anderes als ein Vergleich, beispielsweise



verkaufszahlen < 1000 (ist der Wert von verkaufszahlen kleiner 1000?). Liefert der Vergleich als Ergebnis wahr, ist die Bedingung erfllt und der zur if-Bedingung gehrende Anweisungsblock wird ausgefhrt; andernfalls wird das Programm mit der nchsten Anweisung unter der if-Anweisung (d.h. unter der Zeile end if) fortgesetzt. Die meisten Programmiersprachen stellen fr das Aufsetzen von Vergleichen die folgenden Vergleichsoperatoren zur Verfgung (siehe Tabelle 3.1).

Operator Bedeutung Beispiel (fr i = 3 und j = 50)

== gleich i == 4 // unwahr != ungleich i != 4 // wahr < kleiner i < j // wahr > grer i > j // unwahr = 3 // wahr Tabelle 3.1: Gngige Vergleichsoperatoren



Die Verzweigung Eine Verzweigung bedeutet, dass das Programm in Abhngigkeit vom Wert einer Bedingung einen von mehreren Anweisungsblcken ausfhren soll.

Die einfachste Verzweigung liegt vor, wenn man eine if-Bedingung um einen else-Zweig erweitert: if (Bedingung) then Anweisungen A else Anweisungen B end if Diese Konstruktion kann man wie folgt lesen:

Wenn die Bedingung erfllt ist, dann fhre die Anweisungen A aus, berspringe den else-Block mit den Anweisungen B und fahre mit der nchsten Anweisung hinter der if-else-Konstruktion fort. Wenn die Bedingung nicht erfllt ist, berspringe den Block mit den Anweisungen A, fhre den else-Block mit den Anweisungen B aus, und fahre mit der nchsten Anweisung hinter der if-else-Konstruktion fort. Eine weitere wichtige Form der Verzweigung ist die select- oder case-Verzweigung, die in Abhngigkeit vom Wert eines Ausdrucks zu verschiedenen Stellen in einem Anweisungsblock springt.

Die Schleife Schleifen dienen dazu, eine Anweisung oder einen Anweisungsblock mehrfach hintereinander ausfhren zu lassen. Die wichtigsten Schleifentypen sind die for- und die while-Schleife. Typisch fr Schleifen ist die Einrichtung einer Schleifenvariablen, ber die man kontrolliert, wie oft die Schleife ausgefhrt wird. Dazu wird die Schleifenvariable bei Eintritt in die Schleife auf einen Anfangswert gesetzt, in der Schleife in Einerschritten erhht (oder in irgendeiner anderen Weise verndert) und vor jedem neuen Schleifendurchgang getestet. i = 1 do while (i



i = i + 1 loop Wie wird diese Schleife ausgefhrt?

Vor Eintritt in die Schleife wird die Schleifenvariable i auf 1 gesetzt. Danach beginnt die Schleife, die aus dem Schlsselwort while, der Schleifenbedingung und dem Schleifenkrper (dem nachfolgenden Anweisungsblock) besteht.

In der Schleifenbedingung wird geprft, ob der Wert von i kleiner oder gleich 10 ist. Solange wie die Schleifenbedingung erfllt ist, wird die Schleife ausgefhrt.

Beim Eintritt in die Schleife ist i gleich 1. Die Bedingung ist also erfllt und der Schleifenkrper wird ausgefhrt. Damit die Schleife etwas halbwegs Sinnvolles tut, geben wir im Schleifenkrper zuerst mithilfe von print das Quadrat der Schleifenvariablen aus. Danach wird der Wert der Schleifenvariablen inkrementiert (i = i + 1). Jetzt ist der aktuelle Schleifendurchgang beendet, nicht jedoch die Schleife! Die Programmausfhrung springt an dieser Stelle nmlich zurck zum Anfang der Schleife und zur Schleifenbedingung. Wieder wird berprft, ob der Wert der Variablen i (der jetzt gleich 2 ist) noch kleiner gleich 10 ist. Da dies der Fall ist, wird der Schleifenkrper ein zweites Mal ausgefhrt.

So wird der Schleifenkrper zehn Mal hintereinander ausgefhrt. Beim zehnten Schleifendurchgang wird der Wert von i von 10 auf 11 hoch gesetzt. Nach dem zehnten Schleifendurchgang wird noch einmal die Schleifenbedingung getestet, doch da i jetzt grer als 10 ist, ist die Bedingung nicht mehr erfllt, das heit, der Schleifenkrper wird nicht mehr ausgefhrt, die Programmausfhrung springt hinter die Schleife und wird mit der nchsten Anweisung nach der Schleife fortgesetzt.

Auf dem Bildschirm bleibt die Ausgabe der Schleife zurck: Quadrat von 1 ist gleich 1 Quadrat von 2 ist gleich 4 Quadrat von 3 ist gleich 9 ... Quadrat von 10 ist gleich 100



3.3 Die strukturierte Programmierung Die Programmierung, die Sie im vorangehenden Abschnitt kennengelernt haben mit Daten auf der einen Seite und Daten verarbeitenden Operatoren und Anweisungen auf der anderen Seite , bezeichnet man als imperative Programmierung. Die ersten imperativen Programmiersprachen waren Fortran (1957), Algol (1958), Cobol (1960) und Basic (1964). Daneben entstanden weitere Programmiersprachen, die anderen Programmierparadigmen folgten: beispielsweise dem Paradigma der objektorientierten Programmierung, welches statt der Daten die Objekte in den Mittelpunkt der Programmierung rckte. Noch aber dominierte die imperative Programmierung die Szene und die Siebziger und Achtziger des letzten Jahrhunderts standen ganz im Zeichen einer Sprache: C.

3.3.1 Typisierung Im Vergleich zu Basic, das interpretiert wurde, gehrte C zu den kompilierten Sprachen3.

Fr den Benutzer hat dies verschiedene Vorteile. Zum einen braucht er keinen Interpreter, um die Programme ausfhren zu knnen. Zum anderen wird die Ausfhrungsgeschwindigkeit der Programme wesentlich beschleunigt, da die Programme als Maschinencode vorliegen (EXE-Dateien) und direkt ausgefhrt werden knnen (und nicht erst nach und nach in Maschinencode bersetzt und durch Vermittlung des Interpreters ausgefhrt werden).

Fr uns Entwickler hat die Umstellung ebenfalls Vorteile. Beispielsweise werden die Programme nicht mehr als fr jeden lesbaren Quelltext an die Benutzer und Kunden ausgeliefert, sondern als binre EXE-Datei. Der Quelltext und damit die in das Programm investierte Entwicklungsarbeit werden dadurch vor Nachahmern und illegaler Verwertung geschtzt.

Die Umstellung bringt aber auch Nachteile mit sich. Da Maschinencode prozessorspezifisch ist (also nur von einem bestimmten Prozessor oder einer Prozessorfamilie ausgefhrt werden kann), sind die erstellten EXE-Dateien nicht portabel knnen also nicht zwischen Rechnern mit inkompatiblen Prozessoren und Betriebssystemen ausgetauscht werden.

3 Die Vorstufen zu C waren noch interpretiert.



Am unmittelbarsten betreffen uns aber die Konsequenzen, die das Sprachdesign betreffen.

In interpretierten Sprachen ist es meistens mglich, in ein und derselben Variablen nacheinander unterschiedliche Arten von Daten (der Fachbegriff lautet Datentyp) zu speichern: eineVar = 1 ... eineVar = "Hallo" Hier wird in eineVar zuerst eine Zahl (1) und spter ein String ("Hallo") gespeichert. Zahlen und Strings stellen aber zwei gnzlich verschiedene Datentypen dar, deren Werte

unterschiedlich viel Speicher belegen, nach ganz verschiedenen Verfahren in Bitfolgen und wieder zurck in

Werte codiert werden,

in ganz unterschiedlicher Weise bearbeitet werden knnen (Zahlen kann man beispielsweise addieren, multiplizieren, dividieren etc. mit Strings geht dies nicht).

Grundstzlich gilt, dass jeder Datentyp eine bestimmte Klasse von Daten beschreibt und Speichergre, Binrcodierung und untersttzte Operationen festlegt. Die fr die Programmierung wichtigsten Datentypen sind Ganzzahlen (Integer), Dezimalzahlen (Gleitkommazahlen), Zeichen, boolesche Wahrheitswerte und Strings.

Dezimalzahlen werden in Programmiersprachen blicherweise mit dem Punkt als Trennzeichen zwischen Vorkomma- und Nachkommastellen geschrieben:

3.141592653

Werden in einer Variablen nacheinander Werte unterschiedlicher Datentypen gespeichert, mssen Speicherbelegung und Binrcodierung der Daten an den Datentyp angepasst werden. Ein Interpreter kann dies leisten, ein Compiler kann es nicht. Warum? Der Compiler muss den gesamten Quelltext bersetzen, bevor das Programm ausgefhrt wird. Kann eine Variable unterschiedliche Arten von Daten aufnehmen, ergeben sich aber schnell

Icon STOPP

Icon ACHTUNG



Situationen, in denen sich nicht vorhersagen lsst, welche Art von Wert zu einem bestimmten Zeitpunkt in einer Variablen steht. Fazit: Der Compiler kann nicht entscheiden, wie er den Wert der Variablen decodieren oder verarbeiten soll.

Sehen Sie sich dazu folgenden Code an, wobei n einen Wert hat, der erst zur Laufzeit festgelegt wird (er knnte beispielsweise ber die Tastatur vom Benutzer eingelesen werden): eineVar = 3; // siehe Funote4 if (n > 10) { eineVar = "Hallo"; } zweiteVar = eineVar; Welcher Wert wird hier in zweiteVar abgespeichert? Die Zahl 3 oder der String Hallo? Ohne den Wert von n zu kennen, kann diese Frage nicht beantwortet werden von uns ebenso wenig wie von dem Compiler.

Ein Interpreter knnte diesen Quelltext dagegen ohne Probleme bersetzen, da er den Code Schritt fr Schritt bersetzt und ausfhrt. Er muss nur irgendwo protokollieren, welche Variable gerade welche Art von Daten enthlt (und diese Information immer dann anpassen, wenn in einer Variablen ein Wert eines anderen Datentyps abgespeichert wird).

Bei der Programmierung stellt sich oftmals die Frage, wann eine bestimmte Information (etwa der Datentyp einer Variablen) verfgbar und bekannt ist. Unterschieden wird hierbei zwischen der Laufzeit (whrend der Ausfhrung des Programms) und der Kompilierzeit (vor der Ausfhrung des Programms; also zu einem Zeitpunkt, wo nur der reine, noch zu kompilierende Quelltext vorliegt).

4 Das Codefragment wurde bereits ein wenig an die C- (und Java-) typische Syntax angepasst:

Anweisungen werden mit Semikolon abgeschlossen! Anweisungsblcke, etwa von if-Bedingungen werden in geschweifte

Klammern eingefasst!

Icon REF



Typisierte Variablen Damit ein Programm kompilierbar ist, mssen die Datentypen der Variablen und Werte (weitgehend) zur Kompilierzeit bekannt sein. Kompilierte Programmiersprachen wie C oder Java fordern daher vom Programmierer, dass er Variablen, mit denen er arbeiten mchte, vorab deklariert. In der Deklaration sind der Name und der Datentyp der Variablen (bzw. der Werte, die in der Variablen gespeichert werden knnen) anzugeben. Gltige Variablendeklarationen in C sind beispielsweise: int zaehler; float quotient; char zeichen; int wert = 3; // Deklaration mit gleichzeitiger char option = 'b'; // Wertzuweisung (Initialisierung) float bruch = 0.33333; int, float und char sind Schlsselwrter5 von C, die speziell fr die Variablendeklaration in die Sprache aufgenommen wurden.

Fortan kann der Programmierer nur noch mit Variablen arbeiten, die deklariert sind. Versucht er, neue Variablen wie bisher direkt zu verwenden, quittiert der Compiler dies bei der bersetzung des Quelltextes mit einer Fehlermeldung. zahl = 3; // Fehler: zahl nicht definiert quadr = zahl * zahl; // Fehler: quadr nicht definiert Korrekt wre: int zahl; int quadr; zahl = 3; quadr = zahl * zahl; In gleicher Weise schmettert der Compiler Versuche ab, in einer Variablen einen Wert abzuspeichern, der nicht zum Datentyp der Variablen passt: int zahl; zahl = 3.4; /* Fehler: zahl ist vom Typ int, zugewiesen wird aber ein Gleitkommaliteral */

5 Wrter, die zum festen Wortschatz der Sprache gehren



Korrigierte Version: float zahl; zahl = 3.4;

Positive Folgen der Typisierung

Der Compiler stellt sicher, dass Werte und Variablen eines Datentyps nur in einer typgemen Weise verwendet werden. (Sie knnen also beispielsweise nicht Strings miteinander multiplizieren.)

Keine Fehler durch falsch geschriebene Namen Wenn Sie einen Variablennamen falsch schreiben, knnen Sie froh sein, wenn Sie mit einem Compiler arbeiten. float prozentsatz = 0.012; float guthaben = 2000; float gewinn = guthaben * prozenstatz; Ein Interpreter, der Variablen nach Bedarf erzeugt, wird prozenstatz fr eine neue Variable halten, die er diensteifrig anlegt und deren Wert er mit guthaben multipliziert. Welchen Wert hat prozenstatz? Entweder weist der Interpreter der neu angelegten Variablen einen Standardwert zu, beispielsweise 0, oder er interpretiert einfach das zufllige Bitmuster, das er in der neu angelegten Variablen vorfindet, als Wert. Auf jeden Fall wird der Wert nicht dem Wert in prozentsatz entsprechen und das Programm wird falsche Ergebnisse liefern.

Ein Compiler wird dagegen sofort feststellen, dass der Name prozenstatz nicht deklariert ist und eine Fehlermeldung ausgeben.

Einfachere und effizientere Speicherverwaltung Auch wenn Sie in hheren Programmiersprachen mit Integern, Gleitkommazahlen, Strings und anderen Daten arbeiten, drfen wir nicht vergessen, dass alle diese Daten vom bersetzer in Bitfolgen codiert werden. Fr jeden Datentyp gibt es dazu ein eigenes Codierungsverfahren: fr Integer beispielsweise das 2n+1-Komplement, fr Gleitkommazahlen die IEEE 754, fr Zeichen den Unicode, Strings werden meist als Folgen von Zeichen codiert. Fr die elementaren Datentypen (Integer, Gleitkomma, Zeichen, Boolean, nicht aber String!) liefern diese Codierungsverfahren Bitfolgen fester Gre.

Steht der Datentyp einer Variablen von vornherein fest, kann der bersetzer dem Datentyp entnehmen, wie viel Speicher er fr die



Variable reservieren muss. Dieses sehr effiziente und speicherschonende Verfahren ist typisch fr Compiler.

Interpreter, die Datentypwechsel gestatten, mssen den bentigten Speicher hingegen von vornherein so berechnen, dass er fr alle Datentypen ausreicht, oder dynamisch, d.h. zur Laufzeit, bei jedem Datentypwechsel neuen Speicher reservieren.

bersichtliche Zusammenfassung der Variablendeklarationen Variablendeklarationen mssen nicht an dem Ort stehen, wo die Variable erstmalig verwendet wird. Sie mssen der Verwendung lediglich vorangestellt sein. Der Programmierer kann dies dazu nutzen, wichtige Variablen am Anfang des Programms zusammenzuziehen. Die Programme werden dadurch meist bersichtlicher und besser verstndlich. Lediglich lokal bentigte Hilfsvariablen, beispielsweise Schleifenvariablen, werden vor Ort deklariert.

Negative Folgen der Typisierung Die strenge Abgrenzung der Datentypen, die vom Compiler berwacht wird, fhrt zu besseren, weil sichereren Programmen. Sie kann sich aber auch als extrem strend und nervttend erweisen dann nmlich, wenn der Programmierer darauf angewiesen ist, einen Wert von einem Datentyp in einen anderen umzuwandeln. Betrachten wir noch einmal das Basic-Programm aus dem Abschnitt Die hheren Programmiersprachen: ' Programm zur Berechnung des Kreisumfangs print "Geben Sie einen Radius ein: " input radius umfang = 2 * 3.1415 * radius print "Der Kreisumfang betraegt " umfang In der dritten Zeile liest das Programm eine Eingabe ber die Tastatur ein und speichert diese in der Variablen radius. Eingaben von der Tastatur sind aber stets Zeichenfolgen (Strings). Wenn der Anwender also beispielsweise 10 eintippt, so schickt er nicht die Zahl 10, sondern den String "10" an das Programm! Der Basic-Interpreter macht radius daher zu einer String-Variablen.

Eine Zeile darunter taucht radius in einer Multiplikation auf. Die Multiplikation ist aber nur fr Zahlen, nicht fr Strings mglich. Der Basic-Interpreter merkt dies und wandelt den String "10" automatisch in die Integer-Zahl 10 um und rechnet mit dieser weiter.



In der letzten Zeile haben wir schlielich die umgekehrte Typwandlung: In umfang steht eine Gleitkommazahl, die vom Interpreter fr die Ausgabe auf die Konsole in einen String umgewandelt wird.

Ein Compiler wrde eine solche Vorgehensweise nie untersttzen. Zuerst wrde er vom Programmierer fordern, dass radius als String-Variable und umfang als float-Variable deklariert werden mssen. Kommt der Programmierer dieser Aufforderung nach, bemngelt der Compiler, dass die String-Variable radius nicht in Multiplikationen und die float-Variable umfang nicht in Ausgaben verwendet werden knnen.

Typumwandlungen Das obige Beispiel verdeutlicht wohl eindrcklich, dass eine sinnvolle Programmierung ohne die Mglichkeit zur Umwandlung von Datentypen nicht denkbar ist. Kompilierte und interpretierte Sprachen unterscheiden sich aber zumeist darin, welche Art von Typumwandlungen sie zulassen und wie diese durchgefhrt werden.

So erlauben die meisten interpretierten Programmiersprachen die Umwandlung des Typs von Variablen, die kompilierten Programmiersprachen hingegen nur die Umwandlung von Werten. int eineZahl = 3; float andereZahl; andereZahl = eineZahl; Hier wird in der dritten Zeile der Wert 3 aus der int-Variablen ausgelesen, in einen float-Wert umgewandelt (3.0) und in der float-Variablen andereZahl abgespeichert. eineZahl enthlt danach immer noch den int-Wert 3! Weiterhin gibt es in streng typisierten, kompilierten Sprachen nur wenige Typumwandlungen, die automatisch durchgefhrt werden. (Ein Beispiel fr eine automatische Typumwandlung in C ist die im obigen Beispiel demonstrierte Umwandlung eines int-Werts in einen float-Wert.) Bestimmte Typumwandlungen knnen vom Programmierer durch Voranstellung des gewnschten Zieltyps erzwungen werden beispielsweise die Umwandlung eines float-Werts in einen int-Wert (wobei die Nachkommastellen verloren gehen).



int eineZahl; float andereZahl = 3.4; eineZahl = (int) andereZahl; Schlielich gibt es die Mglichkeit, die gewnschte Typumwandlung selbst zu programmieren. Diese Mglichkeit steht selbstverstndlich immer offen, kann sich aber als recht mhsam erweisen. Manchmal hat der Programmierer aber auch Glck und es gibt in der Standardbibliothek passende Funktionen, die die gewnschte Typumwandlung implementieren.

3.3.2 Funktionen Funktionen sind ein von vielen Programmiersprachen angebotenes Hilfsmittel zur Modularisierung des Programmcodes (in rein objektorientierten Sprachen wie Java treten an die Stelle der Funktionen die Klassen und deren Methoden, doch dazu spter mehr).

Warum empfiehlt es sich, Programmcode zu modularisieren? Erstens wird der Programmquelltext bersichtlicher. Wenn Sie ein mittelgroes Programm von einigen Hundert Zeilen, Anweisung fr Anweisung aufsetzen, werden Sie irgendwann groe Schwierigkeiten haben zu verstehen, was in Ihrem Programm eigentlich vorgeht (noch schwieriger drfte dies fr andere Programmierer sein, die Ihr Programm spter eventuell berarbeiten und warten mssen). Mithilfe von Funktionen knnen Sie grere Programme in Teilprobleme auflsen.

Nehmen wir an, Sie mchten ein Programm schreiben, das mehrere Zahlenwerte einlesen und daraus den Mittelwert berechnen soll. Anstatt den Code direkt Anweisung fr Anweisung niederzuschreiben, knnen Sie das Programm in die folgenden drei Teilprobleme auflsen: Werte einlesen Mittelwert berechnen Ergebnis ausgeben Nachdem Sie dies getan haben, schreiben Sie fr jedes der drei Teilprobleme eine eigene Funktion, die das Teilproblem bearbeitet. Im Hauptteil des Programms brauchen Sie dann nur noch nacheinander die drei Funktionen aufzurufen.

Der zweite Grund, der fr die Auslagerung von Code in Funktionen spricht, ist, dass man Funktionen sehr gut wiederverwerten kann. Eine einmal im Programm definierte Funktion kann man nmlich an jeder beliebigen Stelle



des Programms aufrufen. Stellen Sie sich vor, Sie mssen in Ihrem Programm an verschiedenen Stellen eine recht komplizierte mathematische Formel berechnen. Ohne Funktionen mssten Sie an jeder Stelle, an der die Formel berechnet werden soll, die Anweisungen zur Berechnung der Formel neu aufsetzen. (Sie knnen den Code natrlich kopieren, doch wenn Sie spter im Code einen Fehler bemerken, haben Sie immer noch das Problem, nachtrglich smtliche Stellen aufsuchen und den Fehler beheben zu mssen.) Mit Funktionen knnen Sie eine Funktion zur Berechnung der Formel schreiben und brauchen diese dann nur noch an den betreffenden Stellen aufzurufen.

Definition und Aufruf Letzten Endes ist eine Funktion nichts anderes als ein Anweisungsblock, der mit einem Namen (dem Funktionsnamen) versehen ist, damit man ihn von beliebigen Stellen des Programms aus aufrufen kann. funktionsname() { Anweisung(en); } Weiter unten im Programm knnte diese Funktion dann wie folgt aufgerufen werden: ... funktionsname(); ... Der Funktionsaufruf bewirkt einfach, dass die Programmausfhrung in den Anweisungsblock der Funktion springt. Nach Abarbeitung des Funktionscodes kehrt die Programmausfhrung dann wieder in die Zeile des Aufrufs zurck und das Programm wird fortgesetzt (natrlich ohne nochmalige Ausfhrung der Funktion).

Funktionen wren aber nicht sehr hilfreich, wenn es nur darum ginge, einen ausgelagerten Anweisungsblock auszufhren. Darum gestatten Funktionen es auch, Werte vom Aufrufer entgegenzunehmen und Ergebnisse an den Aufrufer zurckzuliefern. Betrachten Sie hierzu die folgende C-Funktion, die einen int-Wert entgegennimmt und das Quadrat dieses Werts zurckliefert. int quadrat(int n) { int ergebnis; ergebnis = n * n;



return ergebnis; } Der Name dieser Funktion ist quadrat. Sie definiert einen int-Parameter namens n, ber den sie beim Aufruf einen int-Wert als Argument entgegennimmt. Dann folgt der Anweisungsblock der Funktion, in dem zuerst eine lokale Variable ergebnis deklariert wird. Diese Variable kann nur innerhalb der Funktion quadrat verwendet werden. In der nchsten Zeile wird das Quadrat des bergebenen int-Werts berechnet (n * n) und in der lokalen Variablen ergebnis abgespeichert. In der letzten Anweisung wird das berechnete Quadrat an den Aufrufer zurckgeliefert.

Um einen Ergebniswert zurckliefern zu knnen, muss man in der Funktionsdefinition vor dem Funktionsnamen den Datentyp des zurckgelieferten Werts angeben (in unserem Beispiel int) und im Anweisungsblock der Funktion den Wert mithilfe des Schlsselworts return abschicken. Das Schlsselwort return liefert nicht nur den bergebenen Wert zurck, sondern beendet auch die Funktion. Nachfolgende Anweisungen werden also nicht mehr ausgefhrt.

Soll eine Funktion keinen Rckgabewert zurckliefern, gibt man in der Funktionsdefinition als Rckgabetyp void an und verzichtet auf die return-Anweisung. void eine_funktion() { ... }

Sehen wir uns noch an, wie eine solche Funktion aufgerufen wird.

Wenn Sie ein Programm aufrufen, wird es Anweisung fr Anweisung ausgefhrt. Das bedeutet aber nicht, dass die erste ausgefhrte Anweisung auch die oberste Anweisung im Programmquelltext ist. Die meisten Programmiersprachen definieren vielmehr spezielle Eintrittspunkte. In C ist dies beispielsweise eine besondere Funktion namens int main(). Jedes C-Programm muss ber eine solche main()-Funktion verfgen, und mit dem Aufruf dieser Funktion beginnt die Ausfhrung des Programms.

Icon STOPP

Icon REF

main() als Startpunkt des Programms



01 #include 02 03 int quadrat(int n) { 04 int ergebnis; 05 06 ergebnis = n * n; 07 return (ergebnis); 08 } 09 10 int main() { 11 int loop; 12 int erg; 13 14 for (loop=1; loop



Durchlauf der for-Schleife wird zuerst die Funktion quadrat() aufgerufen und ihr als Argument der aktuelle Wert der Schleifenvariablen loop bergeben (Zeile 15). Dieser Wert wird beim Aufruf in den Parameter n der Funktion kopiert. Jetzt wird die Funktion ausgefhrt. Sie berechnet das Quadrat von n und liefert das Ergebnis an den Aufrufer zurck.

Zurck in Zeile 15 nimmt der Aufrufer (hier die main()-Funktion) den von der Funktion zurckgelieferten Wert entgegen und speichert ihn in der Variablen erg. In Zeile 16 wird der Wert von erg ausgegeben. Danach beginnt der nchste Schleifendurchgang.

Insgesamt gibt das Programm also die Quadrate der Zahlen von 1 bis 10 aus.

Fr eine so einfache Berechnung wie das Quadrat einer Zahl wrde man selbstverstndlich keine eigene Funktion aufsetzen. Erstens spart dies keine Tipparbeit, zweitens kostet ein Funktionsaufruf immer auch zustzliche Laufzeit (weswegen man allgemein versuchen sollte, Funktionen nicht in Schleifen aufzurufen).

Da wir gerade bei der Laufzeitanalyse sind, sei auch noch angemerkt, dass man den Anweisungsblock der Funktion quadrat() auch krzer schreiben kann: int quadrat(int n) { return n * n; }

Imperative Programmierung mit Funktionen wird auch als strukturierte Programmierung bezeichnet.

Bibliotheken Die meisten Programmiersprachen verfgen nur ber wenige, fest in die Sprache integrierte Funktionalitt. Damit die Programmierer aber deswegen nicht laufend das Rad neu erfinden mssen, verfgen diese Programmiersprachen ber umfangreiche Bibliotheken, in denen fr viele Standardaufgaben fertige Lsungen angeboten werden (meist in Form von Funktionen, Klassen oder Objekten).

Icon REF

Icon INFO



So verfgt C anders als Basic ber keinen in die Sprache integrierten Befehl zum Ausgeben von Daten auf die Konsole, dafr gibt es aber in der C-Laufzeitbibliothek die Funktion printf().

3.4 Die objektorientierte Programmierung Die Programmierung mit Zeichen, Integer, Gleitkommazahlen und Strings ist auf die Dauer recht unbefriedigend. Ebenso wie der Programmierer in seinen Quelltexten bei Bedarf Zahlen addiert, multipliziert und dividiert, mchte er irgendwann auch Adressen erfassen, durchsuchen, ausdrucken, Comic-Figuren zeichnen, vergrern, verkleinern oder fr Kreise, Quadrate und andere geometrische Formen Umfang und Flche berechnen. Kurzum, er mchte mit beliebigen Daten arbeiten und hofft, dass die Programmiersprache ihn dabei mglichst tatkrftig untersttzt.

Der uerst wichtigen und interessanten Frage, wie diese Untersttzung aussehen kann, werden wir im Folgenden ausfhrlich nachgehen und dabei ganz nebenbei den Sprung von der imperativen zur objektorientierten Programmierung vollziehen.

3.4.1 Selbst definierte Datentypen Die Grundvoraussetzung fr die Programmierung mit eigenen Datentypen ist, dass diese auf elementare und vordefinierte Datentypen zurckgefhrt werden knnen, die dem Compiler bekannt sind.

Die elementaren Datentypen sind in der Sprache selbst verankert. Zu ihnen gehren in der Regel die Zeichen (char), verschiedene Integer- und Gleitkommatypen, die sich im Wertebereich unterscheiden (beispielsweise short fr Integer-Zahlen von -32.768 bis 32.767 und int fr Integer-Zahlen von -2147483648 bis 2147483647 sowie float fr Gleitkommazahlen mit einfacher und double fr Gleitkommazahlen mit doppelter Genauigkeit). Moderne Sprachen wie Java definieren zudem einen eigenen elementaren Datentyp fr Wahrheitswerte (boolean). Strings sind in der Regel nicht als eigener Typ in der Sprache verankert. In Java gehren sie zu den vordefinierten Typen, die in der Standardbibliothek implementiert sind. Wir drfen sie also ruhigen Gewissens als Ausgangsmaterial fr unsere eigenen Datentypen verwenden.

Tutorium zu Jetzt lerne ich Android 4-Programmierung ISBN 978-

Documents

JavaTutorium