View
2
Download
0
Category
Preview:
Citation preview
Anhang
© Springer Fachmedien Wiesbaden GmbH 2017 H. Müller, F. Weichert, Vorkurs Informatik, DOI 10.1007/978-3-658-16141-5
Ka
pit
el
A
Schlüsselwörter im Sprachumfang von
Java
Die folgende Abbildung A.1 listet alle reservierten Wörter der Programmiersprache Java auf. Hierbei glie-dern sich die reservierten Wörter in Schlüsselwörter der Sprache, in Literale (true, false, null) undWörter auf, die nur reserviert sind, aber nicht verwendet werden. Die nicht genutzten Wörter (z.B. goto)sind aus historischen Gründen reserviert. Für alle reservierten Wörter gilt, dass sie nicht als Bezeichner fürAttribut-, Parameter- oder Klassen-Namen genutzt werden dürfen.
In der alphabetischen Auflistung wird die Bedeutung des reservierten Wortesaufgeführt und zusätzlich einkurzes Beispiel zum Verständnis der Syntax des Java Development Kit (kurz JDK) angegeben.
Befehl Bedeutung
abstract Modifikatorenabstract int berechne();
assert Ausnahme (Error)assert (i>0) && (i<10) : "Falscher Zahlenbereich!";
boolean primitiver Datentypboolean tuerGeschlossen;
break Kontrollflussbreak label;
byte primitiver Datentypbyte var = 64;
case Kontrollflussswitch(wert) { case 1: .... break; ....}
362 A Schlüsselwörter im Sprachumfang von Java
Befehl Bedeutung
catch Ausnahme (Exception)catch (eineException e) {...})
char primitiver Datentypchar vat = ’a’;
class Klassenclass eineKlasse {...}
const nur reserviert
continue Kontrollflusscontinue label;
default Kontrollflussswitch(wert) { case 1: .... break; .... default:...}
do Kontrollfluss (Schleife)do {...} while (x>10);
double primitiver Datentypdouble var = -123.456789e+123;
else Kontrollflussif(a<b) {...} else {...}
enum Klasse (Aufzählung)enum Monate { J, F, M, A, M, J, J, A, S, O, N, D }
extends Klassenclass klasseB extends klasseA {...}
false Literaleboolean tuerGeschlossen = false;
final Modifikatorenfinal pi=1.34;
finally Ausnahme (Exception)finally {...}
float primitiver Datenflussfloat var = 123.45678f;
for Kontrollfluss (Schleife)
363
Befehl Bedeutung
for(int x=0; x<10; x++) {...} )
goto nur reserviert
if Kontrollflussif (a<b) {...}
implements Klassen (Interface)class klasseB implements interfaceA {...}
import Klassenimport javax.swing;
instanceof Verschiedenesif( objectA instanceof klasseA) ...
int primitiver Datentypint var = 1234;
interface Klassen (Interface)interface einInterface {...}
long primitiver Datentyplong var = 123456789L;
native Klassen (Native Interface)native int berechne();
new ReferenzenobjektTyp objektA = new objektTyp();
null LiteraleobjektTyp objektA = null;
package Klassenpackage meinPaket;
private Modifikatoren (Sichtbarkeit)private int var;
protected Modifikatoren (Sichtbarkeit)protected int var;
public Modifikatoren (Sichtbarkeit)public int var;
return Kontrollfluss
364 A Schlüsselwörter im Sprachumfang von Java
Befehl Bedeutung
return wert;
short primitiver Datentypshort var = -1234;
static Modifikatorenstatic int var;
strictfp Klassen (math. Striktheit1)strictfp double berechne(double x, double y) {...}
super Referenzsuper("Peter", matrikelnummer);
switch Kontrollflussswitch(wert) { case 1: .... break; ....}
synchronized Modifikatoren (Multithreading)synchronized void passeAuf() {...}
this Referenzenthis.var = var;
throw Ausnahme (Exception)throw new eineAusnahme();
transient Modifikatoren (Serialisierung)transient int var;
true Literaleboolean tuerGeschlossen = true;
try Ausnahme (Exception)try{...}
void Verschiedenesvoid eineMethode(){...}
volatile Modifikatorenvolatile int var;
while Kontrollflusswhile(a<10){...}
Tabelle A.1: Reservierte Wörter der Programmiersprache Java
1 Berechnung von Fließkommaoperationen streng nach dem IEEE Standard (http://standards.ieee.org).
Ka
pit
el
B
Grundlagen der
Java-ProgrammierumgebungDas vorliegende Kapitel fasst die Grundlagen zur Einrichtung der Java-Programmierumgebung zusam-men. Im einleitenden Kapitel „Installation der Java-Programmierumgebung“ (Abschnitt B.1) wird zunächstdie Installation der eigentlichen Entwicklungsumgebung, dem Java-SDK (Software Development Kit), be-schrieben. Nachfolgend erklärt Abschnitt B.2.1 detailliert den „Aufrufsyntax des Java-Compilers“. Zudemvermittelt der Abschnitt B.3 die Grundlagen zu den „Integrierten Java-Programmierumgebungen“.
B.1 Installation der Java-Programmierumgebung
Die folgenden beiden Abschnitte beschreiben die Installation der Java-Programmierumgebung der FirmaOracle (Vorgängerversionen waren von der Firma Sun), auch Java-SDK (Software Development Kit) ge-nannt, für die Betriebssysteme Windows (Abschnitt B.1.1) und Linux (Abschnitt B.1.2). Für beide Be-triebssysteme sind die notwendigen Installationsdateien über die Internetseite der Firma Oracle1, unter derRubrik „Oracle Technology Network > Java > Java SE > Downloads“, verfügbar. Ergänzend können auchInformationen und Dokumentationen zum Java-SDK abgerufen werden. Zum Zeitpunkt der Drucklegungträgt die aktuelle Java-Version die Bezeichnung
JAVATM Platform, Java SE Development Kit 8 Update 131.
Die in diesem Buch abgedruckten Beispiele sind mit der o.g. Version getestet, sollten aber mit der vorher-gehenden Versionen lauffähig sein.
B.1.1 Installation unter Windows
Zur Installation des SDK ist zuerst die Java-Installationsdatei von der Internetseite der Firma Oracle herun-terzuladen. Diese trägt für 32Bit Betriebssysteme (z.B. Microsoft Windows 7, 32 Bit) den Namen
jdk-8u131-windows-i586.exe
und für 64Bit Betriebssysteme (z.B. Microsoft Windows 7, 64 Bit) den Namen
jdk-8u131-windows-x64.exe .
1 Zum Zeitpunkt der Drucklegung [Stand: Mai 2017] können die jeweils aktuellen Versionen über den Linkhttp://www.oracle.com/technetwork/java/javase/downloads/index.html bezogen werden.
366 B Grundlagen der Java-Programmierumgebung
(a) Installationsauswahl (b) Installationspfad
(c) Erweiterte Laufzeitumgebung (d) Installationsvorgang
Abbildung B.1: Installationsdialoge des Java-SDK mit den (a) Auswahlmöglichkeiten der zu installieren-den Komponenten sowie den Dialogen (b) zum Ändern des Installtionsvezeichnisses (c)zur Festlegung des Installationsverzeichnisses für die erweiterte Laufzeitumgebung (JRE)und (d) zum eigentlichen Installationsvorgang
Der Name kann, abhängig von den ausgewählten Optionen und der jeweils aktuellen Versionsnummerleicht abweichen – die nachfolgende Beschreibung beruht auf der Installation unter dem BetriebssystemWindows 7, 64 Bit und der Java-Version jdk1.8.0_131.
Nach dem Starten des Installationsprogramms sollte nach kurzer Zeit der in Abbildung B.1a dargestellteDialog zur Auswahl der zu installierenden Komponenten zu sehen sein. Neben den eigentlichen Program-men zur Entwicklung von Java-Programmen (Development Tools) besteht die Möglichkeit, Beispielpro-gramme und Demos zu installieren, welche unterschiedliche Anwendungen aufzeigen. Den Dialog solltenwir im Regelfall mit „Next“ verlassen. Eventuell könnte es nur notwendig sein das Installationsverzeichnisfestzulegen, in dem alle notwendigen Dateien abgespeichert werden. Zu beachten ist, dass abhängig vomausgewählten Installationsumfang 300-350 MB Speicherplatz auf der Festplatte belegt werden. In unseremBeispiel verwenden wir den Pfad d:\Program Files\Java\jdk1.8.0_131 als Installationsverzeich-nis – hierzu nehmen wir eine Änderung gemäß der Abbildung B.1b vor. Vor dem Verlassen des Dialogs
B.1 Installation der Java-Programmierumgebung 367
(a) (b) (c)
Abbildung B.2: Windows-Systemdialoge zum Setzen der Systemvariable „PATH“
mit „OK“, schreiben wir zur Sicherheit den eingestellten Installationspfad auf, da der zum Abschluss derInstallation noch einmal benötigen wird.
Um Java-Programme ausführen zu können, wird eine sogenannte Laufzeitumgebung (Java Runtime En-vironment) benötigt. Daher ist es im Verlauf der Installation notwendig, das Verzeichnis zur Installationder erweiterten Laufzeitumgebung (JRE) über den in Abbildung B.1c dargestellten Dialog auszuwählen. InAbhängigkeit der Leistungsfähigkeit des zur Verfügung stehenden Computersystems kann der nachfolgendeInstallationsvorgang (s. Abbildung B.1d) eine gewisse Zeit in Anspruch nehmen.
Nach dem Abschluss der Installation ist das Java Development Kit (J2SE) mit den notwendigen Program-men zur Entwicklung von Java-Programmen in dem zuvor bestimmten Verzeichnis d:\Program Fi-les\Java\jdk1.8.0_131 auf der Festplatte installiert. In diesem Verzeichnis sind im Laufe der Instal-lation noch weitere Unterverzeichnisse angelegt worden. Von Interesse ist für uns speziell das Verzeichnisd:\Program Files\Java\jdk1.8.0_131\bin, da sich in diesem der Java-Compiler javac und derJava-Interpreter java befinden.
Beide Programme lassen sich nur von der Kommando-Eingabeaufforderung starten oder über spezielleProgrammierumgebungen (s. Abschnitt B.3). Leider können beide Programme nach dem bisherigen Instal-lationsverlauf nur aus dem Installationsverzeichnis oder durch zusätzliche Angabe des kompletten Pfadsgestartet werden. Im Falle des Compilers wäre folgende Eingabe notwendig:
d:\Program Files\Java\jdk1.8.0_131\bin\javac .
Um die Befehle des SDK ohne Angabe des kompletten Pfads aus einem beliebigen Verzeichnis ausführenzu können, muss der „Suchpfad“ für Programme angepasst werden. Hierzu ist die Systemvariable PATH umden Pfad zum bin-Verzeichnis des SDK zu ergänzen. Nachdem wir über
Startmenü → Systemsteuerung → System
den Dialog zur Einstellung der Systemeigenschaften geöffnet haben, können wir zur Ansicht „ErweiterteSystemeinstellungen“ wechseln. Wir selektieren zunächst den Button „Umgebungsvariablen“ (s. AbbildungB.2a), wählen in dem sich öffnenden Dialog die Variable „PATH“ aus und drücken dann den Button „Be-
368 B Grundlagen der Java-Programmierumgebung
arbeiten“ (s. Abbildung B.2b). Abbildung B.2c zeigt beispielhaft den resultierenden Dialog. Nachdem derCursor an das Ende der Zeile „Wert der Variablen“ gesetzt wurde, wird zunächst ein Semikolon eingege-ben. Das Semikolon dient als Trennzeichen zwischen verschiedenen Suchpfaden. Jetzt kann die Zeile umden zu Anfang der Installation bestimmten Pfad d:\Program Files\Java\jdk1.8.0_91\bin ergänztund alle Dialoge können mit „OK“ beendet werden. Damit ist die Installation des SDK abgeschlossen.Anschließend sollte eine Java-Programmierumgebung installiert werden (s. Abschnitt B.3).
B.1.2 Installation unter Linux
Die folgende Installation der Java-Programmierumgebung führt diese lokal für einen „normalen“ Benutzerdurch. Die Screenshots beruhen dabei auf dem „Java SE Development Kit 8 Update 131“ (kurz JDK). Fallsdie Installation zentral für alle Benutzer erfolgen soll, muss diese als Administrator (root) durchgeführtwerden. Auf die in diesem Fall notwendigen Schritte wird hier aber nicht näher eingegangen.
Vor einer Neuinstallation des JDK sollte zunächst überprüft werden, ob sich nicht bereits eine Java-Versionauf dem System befindet. Viele aktuelle Distributionen installieren ein JDK standardmäßig mit. Um dieseszu überprüfen, können wir eine Eingabeaufforderung (Konsole) öffnen und den Befehl
java -version
ausführen. Falls keine Java-Umgebung installiert ist, kommt es zur Fehlermeldung „java command notfound“. Ansonsten ist die Informationsausgabe des JDK zu sehen, u. a. mit der Versionsnummer. In diesemFall besteht die Möglichkeit, mit der installierten Version zu arbeiten und nur im Falle von Problemen dieVersion zu wechseln.
Besteht die Notwendigkeit einer Installation, sollte zunächst der Weg über das interne Installationssystemgewählt werden. Distributionen wie z.B. Ubuntu, SuSE, Fedora, Mandrake bieten vielfach die Möglichkeiteiner automatischen Installation oder eines Updates. Im Falle der Distribution Ubuntu lautet der Name deszentralen Installationsprogramms beispielsweise apt bzw. aptitude oder YaSt für die Distribution SuSE.Sollte dieses nicht möglich sein oder Ihre Distribution hierbei Probleme bereiten, beschreibt die folgendeAnleitung, wie die Java-Pakete der Firma Oracle von Hand installiert werden. Entsprechende Dateien zurInstallation, mit den Endungen „.tar.gz“ und „.rpm“2, jeweils für 32 Bit und 64 Bit Systeme3, stehenauf der Internetseite der Firma Oracle (vgl. Abschnitt B.1) zum Download zur Verfügung. Nachfolgendwird der Installationsvorgang am Beispiel der Datei (des Archivs) „jdk-8u131-linux-i586.tar.gz“erklärt. Im ersten Schritt ist es notwendig, das Archiv mittels des Befehls
tar zxvf jdk-8u131-linux-i586.tar.gz
zu entpacken. Hierbei wird davon ausgegangen, dass bereits eine Eingabekonsole geöffnet ist und wir unsin dem Verzeichnis befinden, in dem auch das Archiv abgespeichert wurde. Der Befehl erstellt ein neuesVerzeichnis mit dem Namen „jdk1.8.0_131“, welches alle notwendigen Daten der Java-Programmier-umgebung enthält. Falls es bei der Installation Probleme geben sollte, überprüfen Sie bitte, ob Sie u. a.Schreibrechte in dem Verzeichnis haben. Eventuell hilft es, in Ihr Homeverzeichnis zu wechseln. Dies istmit dem Befehl „cd ∼“ möglich. Die vorliegenden Schritte vermittelt zudem die Abbildung B.3a.
Wir wollen jetzt zunächst überprüfen, ob das Entpacken erfolgreich war und ein erstes Starten des Java-Interpreters möglich ist. Wechseln Sie hierzu bitte mittels des Befehls
cd jdk1.8.0_131/bin
2 RPM-basierte Linux-Distributionen sind u. a. Red Hat und SuSE.3 Installations-Dateien für 32 Bit Systeme sind mit der Kennung „i586“ und 64 Bit Systeme mit der Kennung „x64“
bezeichnet.
B.1 Installation der Java-Programmierumgebung 369
(a) (b)
Abbildung B.3: Eingabeaufforderungen (a) mit dem notwendigen Befehl zum Entpacken des Archivs derJava-Programmierumgebung und (b) Darstellung der weiteren Schritte des Installations-vorgangs
in das Verzeichnis mit den ausführbaren Daten der Java-Programmierumgebung und lassen sich die Versi-onsnummer des Java-Interpreters ausgeben:
./java -version
Sie sollen jetzt eine vergleichbar zur Abbildung B.3b dargestellte Bildschirmausgabe sehen. Da es rechtunkomfortabel ist, immer den kompletten Installationspfad beim Aufruf des Java-Compilers mit anzugeben,sollte das entsprechende Verzeichnis mit in den Suchpfad für ausführbare Programme eingebunden werden.Die Anweisung
export PATH=∼/jdk1.8.0_131/bin:$PATHlöst dieses zunächst für die bash-Shell zufriedenstellend4. Nun sollte die bereits zu Anfang eingegebeneBefehlszeile
java -version
die in Abbildung B.3b gezeigte Meldung ausgeben (die Versionsnummer ist abhängig von der jeweils in-stallierten JDK-Version).
Um den Pfad (PATH) nicht bei jedem Systemstart oder einer neuen Angabeaufforderung erneut setzen zumüssen, besteht die Möglichkeit, den Befehl einer Systemdatei hinzuzufügen. Die folgende Herangehens-weise wird am Beispiel der Systemdatei „.bashrc“, bei Verwendung der bash-Shell, vorgestellt. Sie be-findet sich jeweils im Homeverzeichnis oder kann entsprechend angelegt werden. Für andere Shells erfolgtes aber vergleichbar. Die Datei .bashrc kann mit einem beliebigen Editor geöffnet werden. Auf vielenLinux-Systemen kann dieses mit dem Editor gedit erfolgen. Nachdem dieser Editor über den Befehl
4 Im Falle der C-Shell lautet der entsprechende Befehl „setenv PATH ∼/jdk1.8.0_131/bin:$PATH“
370 B Grundlagen der Java-Programmierumgebung
Abbildung B.4: Bildschirmdarstellung des Editors gedit zur Anpassung der Systemvariablen PATH
gedit ∼/.bashrcgestartet wurde, ist die Zeile export PATH=∼/jdk1.8.0_131/bin:$PATH zu ergänzen (s. Abbildung B.4)und das geänderte File abzuspeichern. Das dargestellte Vorgehen sollte, unabhängig von kleineren Abwei-chungen zwischen den Linux-Distributionen, prinzipiell immer in vergleichbarer Form erfolgen.
B.2 Aufrufsyntax der Java-Entwicklungsprogramme
Die folgenden Abschnitte beschreiben die Syntax der Java-Entwicklungsprogramme java, javac und jar.Da die ergänzenden Optionen sehr umfangreich sind und für die Standardnutzung auch nicht benötigt wer-den, beschränkt sich die Auflistung auf die wichtigsten Optionen. Für die Beispielprogramme in diesemBuch ist es aber nicht notwendig zusätzliche Optionen zu verwenden. Mit zunehmender Programmierarbeitsollte die Programmierung unter Entwicklungsumgebungen erfolgen (s. Abschnitt B.3), die es erlauben,einzelne Optionen den jeweils aktuellen Gegebenheiten anzupassen.
B.2.1 Aufrufsyntax des Java-Compilers javac
Der Java-Compiler javac dient zur Übersetzung einer Java-Quellcodedatei (Dateiname.java) in eineByte-Code-Datei (Dateiname.class). Im Normalfall erfolgt der Aufruf des Compilers gemäß dem fol-genden Format:
javac [Optionen] Dateiname.java
Alternativ kann auch eine Datei angegeben werden, die eine Liste von zu übersetzenden Dateien beinhaltet.In diesem Fall ist die nachfolgende Syntax zu verwenden:
javac [Optionen] @Dateiliste
B.2 Aufrufsyntax der Java-Entwicklungsprogramme 371
Option Erläuterung
-classpath < Verzeichnis > Möglichkeit, eine alternative Liste von Pfaden anzuge-ben, in denen der Compiler nach Klassenbibliothekensucht (s. auch Abschnitt 10).
-d < Verzeichnis > Festlegung eines Verzeichnisses, in dem die übersetz-ten class-Dateien gespeichert werden. Ansonsten wer-den die class-Dateien im gleichen Verzeichnis wie dieQuelldateien abgelegt.
-deprecation Falls in einem Programm Java-Befehle genutzt werden,die aus einer älteren Version des JDK stammen und inder aktuellen Version obsolet sind, erscheint ein entspre-chender Hinweis. Diese Option weist den Compiler an,in diesem Fall einen ausführlicheren Hinweis zu geben.
-help Ausgabe eines kurzen Hilfstextes zur Aufrufsyntax desCompilers.
-X Ergänzend zur Option -help werden auch die nicht Stan-dardoptionen aufgelistet.
-nowarn Verhindert die Ausgabe von Warnhinweisen.-source release Legt fest, welcher Version der Quellcode entsprechen
muss, um akzeptiert zu werden.-sourcepath sourcepath Bestimmung eines zusätzlichen Suchpfades für Quell-
codedateien.-verbose Liefert Informationen über jede geladene Klasse und jede
kompilierte Quelldatei.-target version Erzeugt einen Byte-Code, der nur mit einer „Virtual Ma-
schine“ ab Version release lauffähig ist.
Abbildung B.5: Optionen des Java-Compilers javac
Während des Übersetzungsvorgangs überprüft der Compiler die Dateien auf Abhängigkeiten. Dieses bedeu-tet, dass eine DateiY.java mit einer KlasseY automatisch übersetzt wird, falls dieses für die Übersetzungeiner DateiX.java mit der KlasseX notwendig ist. Ergänzend werden die Byte-Code-Dateien automa-tisch aktualisiert, falls das Datum (und die Uhrzeit) der Quelldatei jünger als der entsprechende Zeitstempelder Byte-Code-Datei ist. Dieser Fall tritt offensichtlich dann ein, wenn die Quellcodedatei bearbeitet wurde.Die zusätzlichen Optionen dienen dazu, den Compiler an unterschiedliche Anforderungen anzupassen (s.Abbildung B.5).
Bei der Angabe der Release-Version können neben der aktuellen Version 1.8 auch die Versionen 1.1 bis 1.6angegeben werden.
372 B Grundlagen der Java-Programmierumgebung
Option Erläuterung
-classpath classpath Möglichkeit, eine alternative Liste von Pfaden, jar-Archiven oder zip-Archiven anzugeben, in denen der In-terpreter nach Klassen sucht (s. auch Abschnitt 10).
-jar Führt eine Klasse aus einem jar-Archiv aus, sofern diesezuvor durch die Manifest-Datei benannt wurde (s. Ab-schnitt B.2.3).
-verbose:class Weist den Interpreter an, bei jeder neu erstellten Klasseeine entsprechende Bildschirmmeldung auszugeben.
-verbose:gc Weist den Interpreter an, bei jeder Aktivierung des Gar-bage Collectors eine entsprechende Bildschirmmeldungauszugeben.
-version Zeigt die Version des Interpreters an.-help Ausgabe eines kurzen Hilfstextes zur Aufrufsyntax des
Interpreters.-X Ergänzend zur Option -help werden auch die nicht Stan-
dardoptionen aufgelistet.
Abbildung B.6: Optionen des Java-Interpreters java
B.2.2 Aufrufsyntax des Java-Interpreters java
Der Java-Interpreter java führt Java-Byte-Code Dateien aus. Lautet der Name der auszuführenden DateiDateiname.class, ist das Argument nur Dateiname. Die Endung class wird nicht mit angegeben.Somit entspricht der Name der Datei auch dem Klassennamen innerhalb der Datei. In der bezeichnetenDatei muss die Methode main deklariert sein, ansonsten kommt es zu einer Fehlermeldung. Neben denmöglichen Optionen können beim Aufruf des Interpreters mit
java [Optionen] Klassenname [Argument(e)]
auch benutzerdefinierte Argumente übergeben werden. Zusätzlich kann auch ein spezielles Java-Archivzur Ausführung angegeben werden. Java bietet die Möglichkeit an, eine Gruppe von Byte-Code-Dateienin einem Archiv zusammenzufassen und diese auch zu komprimieren (s. auch Abschnitt B.2.3). Diesessogenannte jar-Archiv kann direkt ausgeführt werden. Innerhalb des Archivs muss aber auch eine Klassemit einer main-Methode vorhanden sein. Die Aufrufsyntax im Falle eines jar-Archivs ist:
java [Optionen] -jar Dateiname.jar [Argument(e)]
Eine Übersicht der wichtigsten Optionen ist in Abbildung B.6 zu sehen.
B.2.3 Aufrufsyntax des Java-Archivprogramms jar
Das Archivprogramm jar dient dazu, mehrere Byte-Code-Dateien zu einem Archiv zusammenzufassen,dieses zu komprimieren und eine direkte Ausführung über den Java-Interpreter zu erlauben. Die folgende
B.3 Integrierte Java-Programmierumgebungen 373
Aufrufsyntax Erläuterung
jar c[m]f Archiv.jar Eingabedateien Erzeugen eines neuen jar-Archivsjar u[m]f Archiv.jar Eingabedateien Aktualisierung eines bestehenden jar-Archivsjar x[v]f Archiv.jar Entpackt ein vorhandenes jar-Archivjar t[v]f Archiv.jar Listet den Inhalt eines jar-Archivs auf
Abbildung B.7: Aufrufsyntax des Java-Archivprogramms jar
Abbildung B.7 zeigt die Aufrufsyntax des Archivprogramms unter den gebräuchlichen Anwendungsmög-lichkeiten auf.
Im Abschnitt B.2.2, zur Verwendung des Java-Interpreters, wurde beschrieben, dass eine Klasse direkt auseinem jar-Archiv gestartet werden kann. Hierzu ist es aber notwendig, dass eine sogenannte Manifest-Datei (Parameter „m“) in das Archiv mit eingebunden wird. Diese Manifest-Datei manifest.txt bein-haltet die Information, in welcher Klasse die main-Methode deklariert wurde. Falls zwei Klassen klas-seA.class und klasseB.class in einem Archiv zusammengefasst werden sollen und die klasseA diemain-Methode deklariert, ergibt sich folgender Inhalt der Manifest-Datei manifest.txt:
Main-Class: klasseA
Wichtig ist ein Return-Code am Ende der Zeile. Ein jar-Archiv mit Namen Archiv.jar wird dann mitfolgendem Aufruf erzeugt:
jar cvfm Archiv.jar manifest.txt klasseA.class klasseB.class
B.3 Integrierte Java-Programmierumgebungen
Die in diesem Buch vorgestellten Beispielprogramme sind verständlicherweise nicht sehr umfangreich.So ist es leicht möglich, diese mit einem einfachen Editor zu editieren und über die Kommandozeile zucompilieren bzw. auszuführen. Trotzdem ist es im Hinblick auf ein effektives Arbeiten sinnvoller, wenn der„Editor“ beispielsweise auch direkt fehlerhafte Zeilen anzeigt und die Übersetzung automatisiert. DerartigeEditoren werden „Integrierte Programmierumgebungen“ genannt.
B.3.1 Übersicht
Etablierte Vertreter sogenannter integrierter Programmierumgebungen, auch als IDE’s (Integrated Develop-ment Environments) bezeichnet, sind beispielsweise
• Eclipse5
• Java-Editor6
• NetBeans7.
5 Eclipse, aktuelle Version: Eclipse Neon.3 (4.6.3) , http://www.eclipse.org (Stand: Mai 2017)6 Java-Editor, aktuelle Version: 14.05, http://www.javaeditor.org (Stand: Mai 2017)7 NetBeans, aktuelle Version: 8.2, http://netbeans.org (Stand: Mai 2017)
374 B Grundlagen der Java-Programmierumgebung
Diese Programmierumgebungen gewährleisten eine komfortable Softwareentwicklung und sollten deshalbauch nach den ersten Programmierschritten eingesetzt werden.
NetBeans ist eine IDE der Oracle Corporation und kann direkt mit dem JDK installiert werden. Die Installa-tion erfolgt weitestgehend nach dem Prinzip der JDK-Installation. Anstelle der in Abschnitt B.1 genanntenInstallationsdateien sind die Dateien netbeans-8.1-javase-windows (für Windows) bzw. netbeans-8.1-javase-linux.sh (für Linux) zu verwenden. Für Einsteiger (aber auch für Fortgeschrittene) ist derJava-Editor zu empfehlen, da er klar strukturiert ist. Dieser ermöglicht einen schnellen Einstieg, trotz um-fangreicher Optionen.
Eclipse hat sich zu einer etablierten und von vielen Java-Programmierern und Programmierenden genutztenIDE entwickelt. Sie wird ständig erweitert und bietet eine umfangreiche Sammlung von Programmierhilfs-mitteln an. Daher erfolgt eine Beschreibung zur Einrichtung einer Entwicklungsumgebung ebenfalls imAbschnitt B.3.2 am Beispiel von Eclipse.
Für Details zur Installation und Konfiguration der IDEs sei auch auf die Dokumentationen verwiesen, dieüber die Internetseite zum Vorkurs-Buch verfügbar ist.
B.3.2 Einrichtung einer Entwicklungsumgebung am Beispiel von Eclipse
Im Folgenden soll am Beispiel der Entwicklungsumgebung Eclipse unter dem Betriebssystem MicrosoftWindows 7 dargelegt werden, wie diese zur Programmentwicklung genutzt werden kann. Die Erklärunggeht mit Bedacht nur auf grundsätzliche Mechanismen ein. Für weitergehende Ausführungen sei auf dieDokumentation verwiesen, die über die Internetseite verfügbar ist. Sofern eine alternative Entwicklungs-umgebung genutzt werden soll, könnten die nachfolgenden Erklärungen trotzdem hilfreich sein, um grund-sätzliche Konzepte zu verstehen.
Zunächst ist es notwendig, sich die aktuelle Version der Entwicklungsumgebung Eclipse von der Inter-netseite http://www.eclipse.org herunterzuladen. Im Falle der 32Bit-Version sollte der Name bei-spielsweise eclipse-inst-win32.exe lauten. In Abhängigkeit der Version kann sich der Name ent-sprechend ändern. Anschließend sollte das Archiv entpackt werden, beispielsweise in das VerzeichnisD:\Programme\eclipse. Starten wir nun das Programm Eclipse. Nach kurzer Zeit erfolgt bei dem erstenStart der Entwicklungsumgebung Eclipse über den Dialog Select a workspace die Aufforderung dasVerzeichnis festzulegen, in welchem die Java-Projekte gespeichert werden sollen. Für die nachfolgendenAusführungen ist dieses das Verzeichnis D:\Javaprogramme.
Nach dem Start von Eclipse muss zunächst ein neues Projekt angelegen werden. Dieses können wir überdie in Abbildung B.8a dargestellten Menüeinträge durchführen, die gemäß Reihenfolge
File → New → Java Project
auszuwählen sind. Resultierend sollte der in Abbildung B.8b gezeigte Dialog zu sehen sein, welcher uns er-laubt, grundlegende Einstellungen für das Projekt festzulegen. Im Normalfall ist es ausreichend den Namendes neues Projekts unter dem Eintrag „Project name:“ festzulegen – hier können wir beispielsweiseden Namen JavaProgramme festlegen. Unter dem Eintrag „Location“ sehen wir jetzt den komplettenProjektpfad inklusive dem zuvor festgelegten Verzeichnis für das Arbeitsverzeichnis (engl. „workspace“).
Auch sollten wir zur Sicherheit einmal kontrollieren, dass unser Java-SDK korrekt installiert wurde. So-fern unter „Use an execution environment JRE“ der Eintrag „JavaSE-1.8“ steht, sollte es keineProbleme gegeben haben. Ansonsten ist noch einmal zu überprüfen, ob die Installation des Java-SDK er-folgreich abgeschlossen wurde. Weitere Hinweise zur Fehlersuche finden sich auch auf der Internetseitehttp://www.eclipse.org – ebenfalls kann eine E-Mail an buch@vorkurs-informatik.de gesandtwerden. Über den Menüpunkt „Finish“ wird der Dialog geschlossen.
B.3 Integrierte Java-Programmierumgebungen 375
(a) Eclipse
(b) Neues Projekt (c) Neue Klasse
Abbildung B.8: Bildschirmdarstellung (a) der Entwicklungsumgebung Eclipse, (b) zur Einstellung einesneuen Projektes und (c) zum Anlegen einer neuen Klasse
376 B Grundlagen der Java-Programmierumgebung
Abbildung B.9: Bildschirmdarstellung der Entwicklungsumgebung Eclipse bei der Ausführung eines Java-Programms
Im nächsten Schritt ist eine neue Java-Klasse anzulegen, welches in vergleichbarer Form über die Menüfol-ge
File → New → Class
erreicht werden kann und resultierend den in der Abbildung B.8c gezeigten Dialog aufruft. Für dieses ein-leitende Beispiel sollten unter „Name“ die bereits aus Kapitel 4.3 bekannten Klassennamen „JavaSpass“eingetragen und der Dialog über den Menüpunkt „Finish“ geschlossen werden.
Dass diese Schritte beim ersten Mal recht aufwendig und auch eventuell etwas schwierig vorkommen, istvollkommen normal. Wir werden aber merken, dass sich dieser Aufwand beim Programmieren lohnt undmit zunehmender Erfahrung auch recht intuitiv ist.
Die jetzt vorliegende Darstellung der Entwicklungsumgebung erlaubt uns mit der eigentlichen Program-mierung zu beginnen. Dazu geben wir in das mittlere (Editor-)Fenster den aus Kapitel 4.3 bekannten Java-Programmcode ein, sodass sich der in Abbildung B.9 gezeigte Programmaufbau ergibt. Im mit „PackageExplorer“ gekennzeichneten Fenster sind die dem Projekt zugeordneten Java-Klassen aufgeführt – imvorliegenden Fall somit natürlich nur die Klasse „JavaSpass.java“. Jetzt können wir zum ersten Malein Java-Programm aus der Entwicklungsumgebung heraus starten. Hierzu klicken wir mit der Maus aufdas Icon „�“, welches auch mit dem Eintrag „Run JavaSpass“ unterlegt wird. Ohne, dass wir dieses ex-plizit sehen, erfolgt im Hintergrund die Übersetzung des Java-Programms (s. dazu auch Kapitel 4.3). Fallses zu Fehlern bei der Übersetzung kommen sollte, würden diese mit der Kennzeichnung der entsprechen-
B.3 Integrierte Java-Programmierumgebungen 377
Abbildung B.10: Bildschirmdarstellung der Entwicklungsumgebung Eclipse bei der Fehlersuche mittelsdem Mechanismus „Debugging“
den Zeilen und Fehlermeldungen angezeigt. Wir gehen jetzt aber einmal davon aus, dass es keine Fehlergegeben hat. Daher sollte die Ausgabe „Viel Spass mit dem Vorkurs Informatik.“ in dem mit „Console“bezeichneten Fenster zu sehen sein.
Zum Abschluss dieser Einführung in die Nutzung einer Entwicklungsumgebung wollen wir uns einen Me-chanismus zum Auffinden von Fehlern ansehen, das sogenannte „Debugging“8. Dieser Modus erlaubt unsbeispielsweise den Programmlauf zeilenweise auszuführen oder den Wert einzelner Variablen anzusehen.Um diesen zuletzt genannten Mechanismus testen zu können, sollte die main-Methode der Klasse „Ja-vaSpass.java“ wie folgt abgewandelt werden:
String ausgabe = "Viel Spass mit dem Vorkurs Informatik.";System.out.println(ausgabe);
Jetzt müssen wir noch einen sogenannten Haltepunkt (engl. Breakpoint) festlegen, an dem das Programmwährend der Ausführung angehalten wird. Hierzu gehen wir mit der Maus über den Balken, der links nebendem Java-Quellcode zu sehen ist – auf der Höhe der Zeile „System.out.println(ausgabe);“. Wirkönnen jetzt über den Menüpunkt „Toggle Breakpoint“ im kontextsensitiven Menü (rechte Maustaste)einen Haltepunkt setzen, der durch einen entsprechenden Punkt symbolisiert wird. Um nachfolgend denin Abbildung B.10 dargestellten Debug-Modus zu aktivieren, starten wir das Programm über das Symbol,
8 Debugging (dt. entwanzen) ist ein Mechanismus zum Auffinden von (Programm-)Fehlern, die auch Bugs genanntwerden.
378 B Grundlagen der Java-Programmierumgebung
welches mit einem „Insekt“ gekennzeichnet ist. Die Auswirkung des Haltepunktes ist, dass das Programmgenau in der zuvor gekennzeichneten Zeile unterbrochen wird und wir eine Übersicht zum aktuellen Pro-grammstatus erhalten. Beispielsweise liefert das Fenster „Variables“ eine Übersicht der aktuell im Pro-gramm genutzten Variablen und deren Inhalt – in unserem Beispiel ist die Variable „ausgabe“ mit demInhalt "Viel Spass mit dem Vorkurs Informatik." verzeichnet.
Da diese Einführung nur die Grundzüge zur Verwendung einer Entwicklungsumgebung vermitteln konnte,ist es notwendig, sich selber weiter mit dieser vertraut zu machen. Auch sei auf die Dokumentationenverwiesen, die zu den jeweiligen Entwicklungsumgebungen verfügbar sind.
Ka
pit
el
C
Literaturverzeichnis
Informatik (allgemein)
• P. Rechenberg und G. Pomberger, Informatik-Handbuch, 4. Auflage, Hanser-Verlag, 2006
• V. Claus, A. Schwill, Duden Informatik, Bibliographisches Institut, 2006
Programmierung
• C. Heinisch, F. Müller, J. Goll, Java als erste Programmiersprache, Springer Vieweg, 8. Auflage, 2016.
• G. Krüger, Java-Programmierung - Das Handbuch zu Java 8, O’Reilly Verlag GmbH & Co. KG, 8.Auflage, 2014.
• J. Niederst, HTML kurz & gut, 5. Auflage, O’Reilly, 2014.
• C. Musciano, B. Kennedy, HTML und XHTML, Das umfassende Referenzwerk, O’Reilly, 4. Auflage,2006.
• SELFHTML, HTML-Dateien selbst erstellen, http://de.selfhtml.org (letzter Zugriff: 30.04.2017).
Erweiterte Programmierkonzepte
• C. Wagenknecht, Programmierparadigmen: Eine Einführung auf der Grundlage von Racket, Vieweg+TeubnerVerlag, 2016.
• B. Stroustrup, Die C++-Programmiersprache, Addison-Wesley, 4. Auflage, 2000.
• B. Stroustrup, F. Langenau, Die C++-Programmiersprache: Aktuell zu C++11, Carl Hanser VerlagGmbH & Co. KG, 2015.
• U. Kirch, P. Prinz, C++ - Lernen und professionell anwenden, mitp, 7. Auflage, 2015.
• M. A. Weiss, C++ for Java Programmers, Prentice Hall, 2003.
380 C Literaturverzeichnis
• D. Louis, Visual C++ 2010: Das umfassende Handbuch für Programmierer, Addison-Wesley, 2010.
• C. Kecher, A. Salvano, UML 2.5: Das umfassende Handbuch, Springer, 2015.
• B. Oestereich, A. Scheithauer, S. Bremer, Analyse und Design mit der UML 2.5: Objektorientierte Soft-wareentwicklung, 11. Auflage, De Gruyter Oldenbourg, 2013.
• H. Balzert, Lehrbuch der Softwaretechnik: Entwurf, Implementierung, Installation und Betrieb, SpektrumAkademischer Verlag, 2012.
Datenstrukturen und Algorithmen
• I. Wegener, Effiziente Algorithmen für grundlegende Funktionen, Teubner, 2. Auflage, 1996.
• T. Ottmann, P. Widmayer, Algorithmen und Datenstrukturen, Spektrum Akademischer Verlag, 5. Auflage,2012.
• R. Sedgewick, K. Wayne, Algorithmen: Algorithmen und Datenstrukturen, Pearson Studium - IT, 2014.
Vom Programm zum Rechner
• U. Schöning, Theoretische Informatik kurzgefaßt, Spektrum Akademischer Verlag, 5. Auflage, 2008.
• I. Wegener, Theoretische Informatik - eine algorithmenorientierte Einführung, B.G. Teubner, 3. Auflage,2005.
• W. Oberschelp, G. Vossen, Rechneraufbau und Rechnerstrukturen, Oldenbourg, 9. Auflage, 2006.
• J.S. Ullman, M. S. Lam, R. Sethi, A. V. Aho, Compiler: Prinzipien, Techniken und Werkzeuge, Addison-Wesley Verlag, 2. Auflage, 2008.
Stichwortverzeichnis
Normalerweise sind Seitenzahlen aufrecht gedruckt. Wichtige Verweise, z. B. auf den Ort, an dem ein Be-griff definiert wird, werden fett gedruckt.
Symbols
+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58¬ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62∨ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62∧ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58, 178- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178/ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39:: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218, 245& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231&& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
A
Ablaufstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Ableitung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345unmittelbare. . . . . . . . . . . . . . . . . . . 339, 340von Worten . . . . . . . . . . . . . . . . . . . . . . . . 340
abstract . . . . . . . . . . . . . . . . . . . . . . . . . 255, 361Abstract Windows Toolkit . . . . . . . . . . . 179, 191abstrakte Methode . . . . . . . . . . . . . . . . . . . . . . . 200Abstraktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8, 16Accessibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192ActionEvent . . . . . . . . . . . . . . . . . . . . . . . . . . 202ActionListener . . . . . . . . . . . . . . . . . . 200, 202actionPerformed . . . . . . . . . . . . . . . . . . . . . 202add . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197addActionListener . . . . . . . . . . . . . . . . . . . 202addElement . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Addierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3291-Bit-Addierer . . . . . . . . . . . . . . . . . . . . . 329
Adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112, 235Adressvariable . . . . . . . . . . . . . . . . . . . . . . . . . . 231Aggregation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257Aktualisierung. . . . . . . . . . . . . . . . . . . . . . 206, 211Akzeptieren eines Wortes . . . . . . . . . . . . . . . . 353
akzeptierte Sprache . . . . . . . . . . . . . . . . . . . . . . 353Alan Turing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349Algorithmenentwurf . . . . . . . . . . . . . . . . 9, 19, 23
Algorithmus . . . . . . . . . . . . . . . . . . . . . . 15, 17, 26binäre Suche . . . . . . . . . . . . . . . . . . . . . . . 291Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . 294Entferne . . . . . . . . . . . . . . . . . . . . . . . . . . . 295Minimumsuche . . . . . . . . . . . . . . . . . . . . . 73Sortieren durch Mischen . . . . . . . . . . . . . 95Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114Suche für einen binären Suchbaum . . . 301
Alphabet . . . . . . . . . . . . . . . . . . . . . . . . . . . 337, 339and-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . 323andere Programmierstile . . . . . . . . . . . . . . . . . 141Anfangszustand . . . . . . . . . . . . . . . . . . . . . . . . . 353Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
bedingte . . . . . . . . . . . . . . 27, 30, 31, 66, 67
if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66leere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Anweisungsfolge . . . . . . . . . . . . . . . . . . . . . . . . . 30Anwendungsfall
Diagramm . . . . . . . . . . . . . . . . . . . . 250, 251Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38, 178
applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178applet code . . . . . . . . . . . . . . . . . . . . . . . . . . 179Appletviewer . . . . . . . . . . . . . . . . . . . . . . . . . . . 180appletviewer . . . . . . . . . . . . . . . . . . . . . . . . . 180Applikation . . . . . . . . . . . . . . . . . . . . . . . . . . 38, 41
arithmetischerAusdruck . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
382 STICHWORTVERZEICHNIS
Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
arithmetischer Ausdruck . . . . . . . . . . . . . . . . . . 58Array . . . . . . . . . . . . . . . . . . . . . . . . . . . 55, 56, 303
mit Verweise . . . . . . . . . . . . . . . . . . . . . . . 112ohne Verweise . . . . . . . . . . . . . . . . . . . . . 112sortiertes . . . . . . . . . . . . . . . . . . . . . . . . . . 289unsortiertes . . . . . . . . . . . . . . . . . . . . . . . . 286
ASCII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319Assembler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . 143Assemblersprache . . . . . . . . . . . . . . . . . . . . . . . 310assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257asymptotische Aufwandsanalyse . . . . . 265, 268
asymptotischer Zeitaufwand . . . . . . . . . . . . . . 294Attribut . . . . . . . . . . . . . . . . . . . 115, 119, 155, 157Attributdeklaration . . . . . . . . . . . . . . . . . . . . . . 118Aufwand
maximaler . . . . . . . . . . . . . . . . . . . . . . . . . 266minimaler . . . . . . . . . . . . . . . . . . . . . . . . . 266
Aufwandsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . 20asymptotische . . . . . . . . . . . . . . . . . 265, 268
Aufwandsmaß . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Aufwandsschranke . . . . . . . . . . . . . . . . . . . . . . 267Ausdruck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
arithmetischer . . . . . . . . . . . . . . . . . . . 58, 59
boolescher . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69, 70
zum Bildschirm . . . . . . . . . . . . . . . . . . . . 183zum Drucker . . . . . . . . . . . . . . . . . . . . . . . 183
Ausgabeanweisung . . . . . . . . . . . . . . . . . . . . . . . 34Ausgabegerät . . . . . . . . . . . . . . . . . . . . . . . . . . . 207ausgeglichener binärer Baum . . . . . . . . . . . . . 300
Ausnahmesituation . . . . . . . . . . . . . . . . . . . . . . 184Auswahlfeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196Automat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
endlicher . . . . . . . . . . . . 142, 349, 350, 353
Automatentypkorrespondierender . . . . . . . . . . . . . . . . . 349
AWT . . . . . . . . . siehe Abstract Windows Toolkitawt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178, 194
B
Backus-Naur-Form (BNF-Form) . . . . . . . . . . 344
Band . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350bandbeschränkte Turingmaschinen . . . . . . . . 349Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296bedingte Anweisung . . . . . . . . 27, 30, 31, 66, 67
Bedingung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31Befehl
arithmetischer . . . . . . . . . . . . . . . . . . . . . . 314logischer . . . . . . . . . . . . . . . . . . . . . . . . . . 314Maschinen- . . . . . . . . . . . . . . . . . . . . . . . . 314Steuerungs- . . . . . . . . . . . . . . . . . . . . . . . . 314Transport- . . . . . . . . . . . . . . . . . . . . . . . . . 314Zuweisungs- . . . . . . . . . . . . . . . . . . . . . . . 314
Befehlsknopf . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Befehlsregister . . . . . . . . . . . . . . . . . . . . . . . . . . 316Befehlssatz . . . . . . . . . . . . . . . . . . . . . . . . . 314, 315
Befehlszeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . 316Benutzungsoberfläche . . . . . . . . . . . . . . . . . . . 191
einfache . . . . . . . . . . . . . . . . . . . . . . 193, 202grafische . . . . . . . . . . . . . . . . . . . . . . . . . . 193
interaktive . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Benutzungsschnittstelle . . . . . . . . . . . . . . . . . siehe
BenutzungsoberflächeBereichsoperator . . . . . . . . . . . . . . . . . . . . . . . . 240Betriebssystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Bewegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Bildpunkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Bildschirmausgabe . . . . . . . . . . . . . . . . . . . . . . 183binäre Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290binärer Baum. . . . . . . . . . . . . . . . . . . . . . . 298, 300
ausgeglichener . . . . . . . . . . . . . . . . . . . . . 300
binärer Suchbaum . . . . . . . . . . . . . . . . . . 296, 300
ausgeglichen . . . . . . . . . . . . . . . . . . 296, 300
Kanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Knoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297Operationen . . . . . . . . . . . . . . . . . . . . . . . 301Wurzel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319Blatt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299Block . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27, 30, 66
bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 361boolesche Funktion . . . . . . . . . . . . . 322, 323, 325
boolescherAusdruck . . . . . . . . . . . . . . . . . . . . . . . 60, 62
Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
boolescher Schaltkreis . . . . . . . . . . . . . . . 326, 327
STICHWORTVERZEICHNIS 383
Borderlayout . . . . . . . . . . . . . . . . . . . . . . . . . 197Bottom-Up-Strategie . . . . . . . . . . . . . . . . . . . . . . 19break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361Browser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180BufferedReader . . . . . . . . . . . . . . . . . . . . . . 184Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312Busarchitektur . . . . . . . . . . . . . . . . . . . . . . . . . . 312Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 195Byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 361Byte-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44Byte-Code-Datei . . . . . . . . . . . . . . . . . . . . . . . . . 44
C
C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143, 217Calendar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Casting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63Casting-Operator . . . . . . . . . . . . . . . . . . . 165, 212catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184, 362char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 362Check Box . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196Chomsky . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Grammatiktypen . . . . . . . . . . . . . . . . . . . 344
Typ-0-Grammatik. . . . . . . . . . . . . . 341, 344Typ-1-Grammatik. . . . . . . . . . . . . . 341, 344Typ-2-Grammatik. . . . . . . . . . . . . . 342, 344Typ-3-Grammatik. . . . . . . . . . . . . . 343, 344
class . . . . . . . . . . . . 39, 115, 118, 157, 202, 362Color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Compiler . . . . . . . . . . . . . . . 8, 221, 244, 335, 344Computational Intelligence . . . . . . . . . . . . . . . . 10Computer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Computergrafik. . . . . . . . . . . . . . . . . . . . . . . . . . . . 9const . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198contains . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206ContentPane . . . . . . . . . . . . . . . . . . . . . . . . . . 198continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
D
d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
DarstellungDezimal- . . . . . . . . . . . . . . . . . . . . . . . . . . 320Dual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320Formel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323grafische . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Hexadezimal- . . . . . . . . . . . . . . . . . . . . . . 320Linie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213p-adische . . . . . . . . . . . . . . . . . . . . . 320, 321
Pseudocode . . . . . . . . . . . . . . . . . . . . . . . . . 23Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323UML-Diagramm . . . . . . . . . . . . . . . . . . . 157Vererbungshierachie . . . . . . . . . . . . . . . . 157
Dateneingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . 183Datenkomponente . . . . . . . . . . . . . . . . . . . . . . . 115Datenobjekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113Datenstrom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183Datenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . 132Datentyp . . . . . . . . . . . . . . . . . . . . . . . . 49, 52, 115
primitiver . . . . . . . . . . . . . . . . . . . . . . 52, 128Debugging. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377default . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Defaultkonstruktor . . . . . . . . . . . . . . . . . . . . . . 121define . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246Definition
Klasse . . . . . . . . . . . . . . . . . . . . . . . . 118, 163Deklaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Attribut . . . . . . . . . . . . . . . . . . . . . . . . . . . 118Funktion . . . . . . . . . . . . . . . . . . . . . . . . 86, 89
Gültigkeitsbereich . . . . . . . . . . . . . . . . . . . 91Java-Klasse . . . . . . . . . . . . . . . . . . . . . . . . 153Klasse . . . . . . . . . . . . . . . . . . . 118, 163, 163
Konstruktor . . . . . . . . . . . . . . . 118, 120, 163Methode . . . . . . . . . . . . . . . . . 118–120, 124Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129Objektvariable . . . . . . . . . . . . . . . . . . . . . 126
Parameter . . . . . . . . . . . . . . . . . . . . . . . . . 119Unterklasse . . . . . . . . . . . . . . . . . . . 157, 162
Variable . . . . . . . . . . . . . . . . . . . . . 46, 49, 50
von Klassen . . . . . . . . . . . . . . . . . . . . . . . 118
deklarative Programmierung . . . . . . . . . . . . . . 145Delegationsmodell . . . . . . . . . . . . . . . . . . 200, 203
Dereferenzierungsoperator . . . . . . . . . . . . . . . 235
Destruktor . . . . . . . . . . . . . . . . . . . . . . . . . 121, 242Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239deterministische Turingmaschinen . . . . . . . siehe
TuringmaschinenDezimaldarstellung . . . . . . . . . . . . . . . . . . . . . . 320
384 STICHWORTVERZEICHNIS
Dezimalzahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320Didaktik der Informatik . . . . . . . . . . . . . . . . . . . 11disjunktive Normalform . . . . . . . . . . . . . . . . . . 323Divide and Conquer . . . . . . . . . . . . . . . . . 107, 109
Divisionganzzahlig . . . . . . . . . . . . . . . . . . . . . . . . . 303
do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362double . . . . . . . . . . . . . . . . . . . . 52, 211, 222, 362Drag und Drop . . . . . . . . . . . . . . . . . . . . . . . . . . 192DrawFrame . . . . . . . . . . . . . . . . . . . . . . . . 202, 203drawString . . . . . . . . . . . . . . . . . . . . . . . . . . . 178Druckerausgabe . . . . . . . . . . . . . . . . . . . . . . . . . 183Dualdarstellung . . . . . . . . . . . . . . . . . . . . . . . . . 320Dualzahl . . . . . . . . . . . . . . . . . . . . . . . . . . . 320, 321
E
Eclipse . . . . . . . . . . . . . . . . . . . . . . . . 217, 373, 374
Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . 311, 313Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183Eingabealphabet . . . . . . . . . . . . . . . . . . . . . . . . 353Eingabeanweisung . . . . . . . . . . . . . . . . . . . . . . . . 71
Eingabegröße . . . . . . . . . . . . . . . . . . . . . . . . . . . 266Eingabewort . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350Einheit
funktionale . . . . . . . . . . . . . . . . . . . . . . . . . 29Elementardateneinheit . . . . . . . . . . . . . . . 266, 269Elementaroperation . . . . . . . . . . . . . . . . . . . . . . 266elementAt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362endlicher Automat . . . . . . . . . 142, 349, 350, 353
Endlichkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Endzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Endzustand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353Entwurf
objektorientierter . . . . . . . . . . . . . . . . . . . 149enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362equals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202Ereignis . . . . . . . . . . . . . . . . . . . . . . . . . . . 202, 203
Empfänger . . . . . . . . . . . . . . . . . . . . 202, 203Ereignisobjekt . . . . . . . . . . . . . . . . . . . . . 203Ereignisquelle . . . . . . . . . . . . . . . . . 200, 203
Ereignisquelle . . . . . . . . . . . . . . . . . . . . . . . . . . 202Ereignisverarbeitung . . . . . . . . . . . . . . . . 200, 203
erweitertes Syntaxdiagramm. . . . . . . . . . . . . . 168
Event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200, 206event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202eventhandling . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . 184, 184
EXIT_ON_CLOSE . . . . . . . . . . . . . . . . . . . . . . . . 199explizite
Rückgabeanweisung . . . . . . . . . . . . . . . . 119Typkonvertierung. . . . . . . . . . . 64, 165, 166
extends . . . . . . . . . . . . . . . . . 157, 163, 179, 362
F
f . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54false . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Farben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Fehlersituation . . . . . . . . . . . . . . . . . . . . . . . . . . 184Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 194Fenstergröße . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Fensterstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . 191Festplatte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313fillRect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207, 362finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Firefox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180Fließkommazahlen . . . . . . . . . . . . . . . . . . . . . . . 52Flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 362FlowLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . 197for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363formale Sprache . . . . . . . . . . . . . . . . . . . . . . . . . 337
Formeldarstellung . . . . . . . . . . . . . . . . . . . . . . . 323Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79, 86
and . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323boolesche . . . . . . . . . . . . . . . . 322, 323, 325Deklaration . . . . . . . . . . . . . . . . . . . . . . . . . 89
nand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323not . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323oder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323or . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323und . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
funktionale Einheit . . . . . . . . . . . . . . . . . . . . . . . 29funktionale Programmierung . . . . . . . . . . . . . 145Funktionsaufruf . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Funktionsname . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
STICHWORTVERZEICHNIS 385
G
Gültigkeitsbereich . . . . . . . . . . . . . . . . . . . . . . . . 92
von Deklarationen . . . . . . . . . . . . . . . . . . . 91ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52Garbage Collector . . . . . . . . . . . . . . . . . . . . . . . 121Gatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326gerichteter Graph . . . . . . . . . . . . . . . . . . . . . . . . 297
get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181getContentPane . . . . . . . . . . . . . . . . . . . . . . 198GlassPane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363Größenordnung . . . . . . . . . . . . . . . . . . . . . . . . . 267Grafikbefehl
einfacher . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Grafikbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . 203Grafikkontext . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Grafikprogrammierung. . . . . . . . . . . . . . . . . . . 191
grafische Benutzungsoberfläche . . . . . . . . . . . 193
grafische Darstellung . . . . . . . . . . . . . . . . . . . . . 30grafische Repräsentation
Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125der Instantiierung eines Objektes . . . . . 127einer Objektvariablen . . . . . . . . . . . . . . . 126einer verzeigerten linearen Liste . . . . . 132
Grammatik . . . . . . . . . . . . . . . . . . . . 336, 337, 340
kontextfreie . . . . . . . . . . . . . . . . . . . 343, 344kontextsensitive . . . . . . . . . . . . . . . . . . . . 344reguläre . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Grammatikregel . . . . . . . . . . . . . . . . . . . . . . . . . 341Grammatiktypen nach Chomsky . . . . . . . . . . 344
Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350gerichteter . . . . . . . . . . . . . . . . . . . . . . . . . 297
Graphical User Interface . . . . . . . . . . . . . 191, 193Graphics . . . . . . . . . . . . . . . . . . . . . . . . . 178, 207Graphics2D . . . . . . . . . . . . . . . . . . . . . . . . . . . 213GregorianCalendar . . . . . . . . . . . . . . . . . . . 181GridLayout . . . . . . . . . . . . . . . . . . . . . . . . . . . 197Groß-O-Notation . . . . . . . . . . . . . . . . . . . 267, 268
Grundfarben . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207GUI . . . . . . . . . . . siehe Graphical User Interface
H
Halbaddierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3291-Bit-Halbaddierer . . . . . . . . . . . . . . . . . 329
Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309Hash-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 303Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . 303, 305
Einfügen . . . . . . . . . . . . . . . . . . . . . . . . . . 305Entfernen . . . . . . . . . . . . . . . . . . . . . . . . . . 305geschlossenes . . . . . . . . . . . . . . . . . . . . . . 305offenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303Suchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305Zeitaufwand . . . . . . . . . . . . . . . . . . . . . . . 303
Hauptspeicher . . . . . . . . . . . . . 313, 314, 314, 316Headerdatei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240height . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179, 208Hexadezimaldarstellung. . . . . . . . . . . . . . . . . . 320Hilfszeichenmenge . . . . . . . . . . . . . . . . . . . . . . 339html . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
I
IDE siehe integrierte Programmierumgebungenif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66, 363if-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
ifndef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246imperative Programmierung . . . . . . . . . . . . . . 144implements . . . . . . . . . . . . . . 200, 202, 257, 363implizite (automatische) Typkonvertierung . 166implizite Typkonvertierung . . . . . . . . . . 164, 166import . . . . . . . . . . . . . . . . . . . 177, 186, 194, 363Import von Paketen . . . . . . . . . . . . . . . . . . . . . . 178
include . . . . . . . . . . . . . . . . . . . . . . 218, 224, 240Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287Induktion . . . . . . . . siehe vollständige InduktionInduktionsanfang . . . . . . . . . . . . . . . . . . . . . . . . 277Induktionsschritt . . . . . . . . . . . . . . . . . . . . . . . . 278Inferface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Informatik . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 8, 8
angewandte . . . . . . . . . . . . . . . . . . . . . . . . . . 9Didaktik . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11praktische . . . . . . . . . . . . . . . . . . . . . . . . . . . 9technische . . . . . . . . . . . . . . . . . . . . . . . . . 8, 9Teilgebiete . . . . . . . . . . . . . . . . . . . . . . . . . . . 8teoretische . . . . . . . . . . . . . . . . . . . . . . . . . . . 9theoretische . . . . . . . . . . . . . . . . . . . . . . . . . 10und Gesellschaft . . . . . . . . . . . . . . . . . . . . 11
Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Informationsdarstellung
386 STICHWORTVERZEICHNIS
zweiwertige . . . . . . . . . . . . . . . . . . . 319, 321
Informationssystem . . . . . . . . . . . . . . . . . . . . . . . . 8Informationsverlust . . . . . . . . . . . . . . . . . . . . . . . 64inputReader . . . . . . . . . . . . . . . . . . . . . . . . . . 184InputStreamReader . . . . . . . . . . . . . . . . . . . 184instabile Schaltung . . . . . . . . . . . . . . . . . . . . . . 332instanceof . . . . . . . . . . . . . . . . . . 164, 166, 363Instantiierung . . . . . . . . . . . . . . . . . . 121, 123, 127
Objekt . . . . . . . . . . . . . . . . . . . . . . . . 126, 129
Unterklasse . . . . . . . . . . . . . . . . . . . . . . . . 164
Instanziierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 240int . . . . . . . . . . . . . . . . . . . . . . . . . 47, 52, 222, 363Interaktionsdiagramm. . . . . . . . . . . . . . . . . . . . 250Interaktionselement . . . . . . . . . . . . . . . . . . . . . . 195Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256interface . . . . . . . . . . . . . . . . . . . . . . . . 256, 363Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178Interpreter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336IOException . . . . . . . . . . . . . . . . . . . . . . . . . . 184
J
JApplet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193Java
virtuelle Maschine (Java VM) . . . . . . . . 44Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178Aufrufsyntax . . . . . . . . . . . . . . . . . . . . . . 370
jar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372javac . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372Debugging . . . . . . . . . . . . . . . . . . . . . . . . 377Grammatik . . . . . . . . . . . . . . . . . . . . . . . . 343Installation . . . . . . . . . . . . . . . . . . . . . . . . 365
Installation unter Linux . . . . . . . . . . . . . 368
Installation unter Windows . . . . . . . . . . 365
integrierte Programmierumgebungen . 373
Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Programmiersprache . . . . . . . . . . . . . . . . . 38Programmierumgebung . . . . . . . . . . . . . 365Quelltextdateien . . . . . . . . . . . . . . . . . . . . . 45
Schlüsselwörter . . . . . . . . . . . . . . . . . . . . 361
java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44, 372Java 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192Java Development Kit (JDK) . . . . . . . . . . . . . 361Java Foundation Class . . . . . . . . . . . . . . . . . . . 191Java Virtual Machine (JVM) . . . . . . . . . . . . . . 336
Java-KlasseDeklaration . . . . . . . . . . . . . . . . . . . . . . . . 153
Java-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . 38ausführen . . . . . . . . . . . . . . . . . . . . . . . . . . . 42kompilieren . . . . . . . . . . . . . . . . . . . . . . . . . 42Minimumsuche . . . . . . . . . . . . . . . . . . 47, 84Sortieren durch Mischen . . . . . . . . . . . . . 99Typ Applikation . . . . . . . . . . . . . . . . . . . . 119
java.awt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191java.io . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184javac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370javax.swing . . . . . . . . . . . . . . . . . . . . . . . . . . 192JButton . . . . . . . . . . . . . . . . . . . . . . . . . . 195, 197JCheckBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196JComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196JComponent . . . . . . . . . . . . . . . . . . . . . . . . . . . 206JDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193JFC . . . . . . . . . . . . . . siehe Java Foundation ClassJFrame . . . . . . . . . . . . . . . . . . . . . . . 193, 194, 198JLabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196JPanel . . . . . . . . . . . . . . . . . . . . . . . 197, 203, 206JRadioButton . . . . . . . . . . . . . . . . . . . . . . . . . 196JSlider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196JWindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
K
künstliche Intelligenz . . . . . . . . . . . . . . . . . . . . . 10Kanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297, 297
Kellerautomatennichtdeterministische . . . . . . . . . . . . . . . 349
Klasse . . . . . . . . . . . . . . . 111, 115, 118, 123, 150
Deklaration . . . . . . . . . . . . . . . 118, 163, 163
Ober- . . . . . . . . . . . . . . . . . . . . 157, 157, 161Objekt- . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156Sub- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157Super- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157Unter- . . . . . . . . . . . . . . . . . . . . . . . . 157, 161
Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237Klassenbibliothek . . . . . . . . . . . . . . 177, 191, 206Klassenbibliotheken . . . . . . . . . . . . . . . . . . . . . 229
C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220Klassendefinition . . . . . . . . . . . . . . . . . . . 118, 163Klassendeklaration
Rumpf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118Klassendiagramm . . . . . . . . . . . . . . . . . . . 250, 252
STICHWORTVERZEICHNIS 387
Klassenname . . . . . . . . . . . . . . . . . . . . . . . 118, 164Klassenrumpf . . . . . . . . . . . . . . . . . . . . . . . . . . . 118Knopf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193Knoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297, 297
innerer . . . . . . . . . . . . . . . . . . . . . . . . 299, 300Kommentar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Kommunikationsweg . . . . . . . . . . . . . . . . . . . . 312Komponente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
leichtgewichtige . . . . . . . . . . . . . . . . . . . . 193schwergewichtige . . . . . . . . . . . . . . . . . . 193Swing- . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Komposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257Konstruktor . 115, 121, 155, 158, 198, 202, 242
Aufruf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127default . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121Deklaration . . . . . . . . . . . . . . . 118, 120, 163leerer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121Oberklasse . . . . . . . . . . . . . . . . . . . . . . . . 161
kontextfreieGrammatik . . . . . . . . . . . . . . . . . . . . 343, 344Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
kontextsensitiveGrammatiken . . . . . . . . . . . . . . . . . . . . . . 344Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Kontrollstrukturif-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
while-Schleife . . . . . . . . . . . . . . . . . . . . . . 68
Korrektheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19korrespondierender Automatentyp . . . . . . . . 349
Kurzschreibweise . . . . . . . . . . . . . . . . . . . . . . . . 24
L
L . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54l . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196LayeredPane . . . . . . . . . . . . . . . . . . . . . . . . . . 198Layout
Manager . . . . . . . . . . . . . . . . . . . . . . . . . . 197Layout-Manager . . . . . . . . . . . . . . . . . . . . . . . . 199
leere Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . 30leerer Konstruktor . . . . . . . . . . . . . . . . . . . . . . . 121leeres Wort . . . . . . . . . . . . . . . . . . . . . . . . . 339, 340leichtgewichtige
Komponente . . . . . . . . . . . . . . . . . . . . . . . 193Leitwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . 315, 317
length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56Line2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211lineare Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132Linie . . . . . . . . . . . . . . . . . . . . . . . . . . 203, 209, 212Linken
dynamisch . . . . . . . . . . . . . . . . . . . . . . . . . 247statisch . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Linker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221, 244Liste
lineare . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132verzeigerte lineare . . . . . . . . . . . . . . . . . . 132
Listenelement . . . . . . . . . . . . . . . . . . . . . . . . . . . 132Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . 379
logische Programmierung . . . . . . . . . . . . . . . . 145logischer Operator . . . . . . . . . . . . . . . . . . . . . . . . 61long . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 363Look & Feel . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
M
main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39, 183Maschinenbefehl . . . . . . . . . . . . . . . . . . . 314, 315
Maschinensprache . . . . . . . 8, 143, 310, 314, 336Mausklick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200Mehrfachvererbung . . . . . . . . . . . . . . . . . 242, 255Menge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
binärer Suchbaum . . . . . . . . . . . . . . . . . . 296Datenstruktur . . . . . . . . . . . . . . . . . . . . . . 287Einfügen . . . . . . . . . . . . . . . . . . . . . . 287, 294Entfernen . . . . . . . . . . . . . . . . . . . . . 288, 295Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . 303mit sortiertem Array . . . . . . . . . . . . . . . . 289mit unsortiertem Array . . . . . . . . . . . . . . 286Operation auf . . . . . . . . . . . . . . . . . . . . . . 285Suchen . . . . . . . . . . . . . . . . . . . . . . . 286, 290Zeitaufwand . . . . . . . . . . . . . . . . . . . . . . . 287
Mensch-Maschine-Interaktion . . . . . . . . . . . . . . 9MenuBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Methode . . . . . . . . . . . . . . . . . . 115, 120, 155, 157
abstrakte . . . . . . . . . . . . . . . . . . . . . . . . . . 200Aufruf . . . . . . . . . . . . . . . . . . . . . . . . 131, 131
Deklaration . . . . . . . . . . . . . . . 118–120, 124Name . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120Rumpf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120statische . . . . . . . . . . . . . . . . . . . . . . . 89, 181
388 STICHWORTVERZEICHNIS
Microsoft Explorer . . . . . . . . . . . . . . . . . . . . . . 180Minimum
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . 29einer Zahlenmenge . . . . . . . . . . . . . . . . . . 23
Minimumsuche . . . . . . . . . . . . . . . . . . . . 25, 47, 79
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . 73Java-Programm . . . . . . . . . . . . . . . . . . . . . 84mit Hilfsfolge . . . . . . . . . . . . . . . . . . . . . . . 80ohne Hilfsfolge . . . . . . . . . . . . . . . . . . . . . 82
Mittelwert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
mod. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303Modellbildung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Modellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
objektorientierte . . . . . . 149, 150, 151, 152Modellierungssprache . . . . . . . . . . . . . . . . . . . 143Modifikator . . . . . . . . . . . . . . . . . . . . . . . . 168, 188
modulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303mouseClicked . . . . . . . . . . . . . . . . . . . . . . . . . 206mouseDragged . . . . . . . . . . . . . . . . . . . . . . . . . 209mouseEntered . . . . . . . . . . . . . . . . . . . . . . . . . 206MouseEvent . . . . . . . . . . . . . . . . . . . . . . . 205, 206mouseExited . . . . . . . . . . . . . . . . . . . . . . . . . . 206MouseListener . . . . . . . . . . . . . . . . . . . 205, 209MouseMotionListener . . . . . . . . . . . . . . . . 209mouseMoved . . . . . . . . . . . . . . . . . . . . . . . . . . . 209mousePressed . . . . . . . . . . . . . . . . . . . . 206, 209mouseReleased . . . . . . . . . . . . . . . . . . . . . . . . 206Multiplizität . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
N
Namenskonventionen . . . . . . . . . . . . . . . . . . . . . 72nand-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 323native . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373new-Operator . . . . . . . . . . . . . . . . . . 127, 129, 363nicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . 60nichtdeterministische
Kellerautomaten . . . . . . . . . . . . . . . . . . . 349Turingmaschinen . . . . . . . . . . . . . . . . . . . 349
Nichtendzeichen . . . . . . . . . . . . . . . . . . . . . . . . 339Nichtterminale . . . . . . . . . . . . . . . . . . . . . . . . . . 339Normalform
disjunktive . . . . . . . . . . . . . . . . . . . . . . . . . 323not-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Notationsregeln in Java . . . . . . . . . . . . . . . . . . . 48
null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126, 363Null-Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
O
Oberklasse . . . . . . . . . . . . . . . . . . . . 157, 157, 161Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . 161
Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212Objekt . . . . . . . . . . . . . . . . . . . . 111, 123, 123, 150
Instantiierung . . . . . . . . . . . . . . . . . 126, 129
Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . 164Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237Objektklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156objektorientiert
Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . 149Modellierung. . . . . . . . . 149, 150, 151, 152Programmierung . . . . . . . . . . . . . . . . . . . 149
Objektorientierte Modellierung . . . . . . . . . . sieheModellierung
Objektorientierte Programmierung . . . . . . . sieheProgrammierung
Objektvariable . . . . . . . . . . . . . . . . . . . . . . . . . . 166Deklaration . . . . . . . . . . . . . . . . . . . . . . . . 126
oder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 323Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . 60
Operand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315Operationscode . . . . . . . . . . . . . . . . . . . . . . . . . 315Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
boolescher . . . . . . . . . . . . . . . . . . . . . . . . . . 60logischer . . . . . . . . . . . . . . . . . . . . . . . . . . . 61new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129Vergleichs- . . . . . . . . . . . . . . . . . . . . . . . . . 60
Optimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348or-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
P
p-adische Darstellung . . . . . . . . . . . . . . . 320, 321
pack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198package . . . . . . . . . . . . . . . . . . . . . . 188, 254, 363Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . 169, 177
paint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178, 206
STICHWORTVERZEICHNIS 389
paintBorder . . . . . . . . . . . . . . . . . . . . . . . . . . 206paintChildren . . . . . . . . . . . . . . . . . . . . . . . . 206paintComponent . . . . . . . . . . . . . . . . . . 206, 212Paket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177, 178
Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Paketsichtbarkeit . . . . . . . . . . . . . . . . . . . 169, 186
Panel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197Parameter
Deklaration . . . . . . . . . . . . . . . . . . . . . . . . 119formaler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Parameterliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87leere Parameterliste . . . . . . . . . . . . . . . . . . 88
Pipe-Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . 220Pixel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231, 235Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . . 170
Präprozessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244primitiver Datentyp . . . . . . . . . . . . . . . . . . 52, 128PrintStream . . . . . . . . . . . . . . . . . . . . . . . . . . 184private . . . . . . . . . . . . . . . . . . . . . . 168, 188, 363Problemabstraktion . . . . . . . . . . . . . . . . . . . . . . . 18Problemanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . 18Problemlösung . . . . . . . . . . . . . . 15, 21, 141, 150Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . 15Produktionsregel . . . . . . . . . . . . . . . . . . . . . . . . 339Programmierparadigma . . . . . . . . . . . . . . . . . . 144Programmiersprache
höhere . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143problemorientiert . . . . . . . . . . . . . . . . . . . 310
Programmiersprache Java . . . . . . . . . . . . . . . . . 38Programmierstile
andere . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141Programmiersystem. . . . . . . . . . . . . . . . . . . . . . . . 8Programmierung . . . . . . . . . . . . . . . 7, 20, 37, 309
deklarative . . . . . . . . . . . . . . . . . . . . . . . . . 145funktionale . . . . . . . . . . . . . . . . . . . . . . . . 145imperative . . . . . . . . . . . . . . . . . . . . . . . . . 144Lexikalik . . . . . . . . . . . . . . . . . . . . . . . . . . 141logische . . . . . . . . . . . . . . . . . . . . . . . . . . . 145objektorientierte . . . . . . . . . . . . . . . . . . . . 149Semantik . . . . . . . . . . . . . . . . . . . . . . . . . . 141Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
protected . . . . . . . . . . . . . . . . . . . . . . . . 188, 363Prozessor . . . . . . . . . . . . . . . . . 311, 313, 314, 317
Pseudocode . . . . . . . . . . . . . . . . . . . . . . . . . . 24, 73Darstellung . . . . . . . . . . . . . . . . . . . . . . . . . 23
public . . . . . . . . . . . . . . . . . . . . . . . 168, 188, 363Punkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203Punktnotation . . . . . . . . . . . . . . . . . . . . . . . . . . . 131Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Q
Quellcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44Quellsprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
R
Rückgabeanweisung . . . . . . . . . . . . . . . . . . . . . . 27explizite . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Rückgabetyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87rückgekoppelte Schaltung . . . . . . . . . . . . . . . . 330Random Access Memory (RAM) . . . . . . . . . 313Reader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184readLine() . . . . . . . . . . . . . . . . . . . . . . . . . . . 184Rechenwerk . . . . . . . . . . . . . . . . . . . . . . . . 315, 317
Rechner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311Rechnerarchitektur . . . . . . . . . . . . . . . . . . . . 8, 311
Rechnernetz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Rechteck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204Rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . 235, 303
Null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Referenzoperators . . . . . . . . . . . . . . . . . . . . . . . 231Referenzvariable . . . . . . . . . . . . . . . 125, 126, 166Register . . . . . . . . . . . . . . . . . . . . . . . 314, 315, 317
Transferebene . . . . . . . . . . . . . . . . . . . . . . 310Registerzuweisung . . . . . . . . . . . . . . . . . . . . . . 348Regler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193reguläre
Grammatik . . . . . . . . . . . . . . . . . . . . . . . . 353Sprache . . . . . . . . . . . . . . . . . . . . . . . 341, 353
Reihenfolge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Rekurrenzformel . . . . . . . . . . . . . . . . . . . . . . . . 275Rekursion . . . . . . . . . . . . . . . . . . . . . . 95, 107, 109
repaint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206reserviertes Wort . . . . . . . . . . . . . . . . . . . . . . . . 361return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88, 364RGB-Farbmodell . . . . . . . . . . . . . . . . . . . 207, 207
390 STICHWORTVERZEICHNIS
RootPane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198RS-Flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
S
Schachtelung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91Schaltkreis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
boolescher . . . . . . . . . . . . . . . . . . . . 326, 327
Schaltung . . . . . . . . . . . . 309, 319, 326, 327, 330instabile . . . . . . . . . . . . . . . . . . . . . . . . . . . 332rückgekoppelte . . . . . . . . . . . . . . . . . . . . . 330
Schieberegler . . . . . . . . . . . . . . . . . . . . . . . . . . . 196Schlüsselwörter
im Sprachumfang von Java . . . . . . . . . . 361
Schleife . . . . . . . . . . . . . . . . . . . . . . 26, 30, 33, 330schwergewichtige
Komponente . . . . . . . . . . . . . . . . . . . . . . . 193Semantik . . . . . . . . . . . . . . . . . . . . . . . 19, 337, 354
axiomatische . . . . . . . . . . . . . . . . . . . . . . . 356Beschreibung . . . . . . . . . . . . . . . . . . . . . . 356denotationelle . . . . . . . . . . . . . . . . . . . . . . 356Einsatzgebiete . . . . . . . . . . . . . . . . . . . . . 357Information oder Begriffe . . . . . . . . . . . 355operationelle . . . . . . . . . . . . . . . . . . . . . . . 356reale Welt . . . . . . . . . . . . . . . . . . . . . . . . . 354Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
Schemata . . . . . . . . . . . . . . . . . . . . . . . . . . 354sprachliche Repräsentation . . . . . . . . . . 354
Semikolon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46setActionCommand . . . . . . . . . . . . . . . . . . . . 202setColor . . . . . . . . . . . . . . . . . . . . . . . . . 207, 213setDefaultCloseOperation . . . . . . . . . . 199setLine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211setLocation . . . . . . . . . . . . . . . . . . . . . . . . . . 198setPreferredSize . . . . . . . . . . . . . . . . . . . . 197setSize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195setStroke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213setVisible . . . . . . . . . . . . . . . . . . . . . . . . . . . 194short . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 364Sichtbarkeit . . . . . . . . . . . . . . . . . . . . . . . . 167, 202
Paket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10sizeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222Slider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 196Software
-Technologie . . . . . . . . . . . . . . . . . . . . . . . . . 9
Entwicklung . . . . . . . . . . . . . . . . . . . . . . . 250Sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
durch Minimumsuche . . . . . . . . . . . 79, 271durch Mischen (1) . . . . . . . . . . . . . . . . . . 273durch Mischen (2) . . . . . . . . . . . . . . . . . . 281
Sortierproblem . . . . . . . . . . . . . . . . . . . . . . . . . . 283
sortiertes ArrayÜberlauf . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Speicher . . . . . . . . . . . . . . . . . . . . . . . 311, 313, 330Speicheradressregister . . . . . . . . . . . . . . . . . . . 316Speicheraufwand . . . . . . . . . . . . . . . . . . . 266, 269
Speicherbausteine . . . . . . . . . . . . . . . . . . . . . . . 330
Speicherdatenregister . . . . . . . . . . . . . . . . . . . . 316Speicherzelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Spezialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . 161Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337, 340
akzeptierte . . . . . . . . . . . . . . . . . . . . . . . . . 353
formale . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
kontextfreie . . . . . . . . . . . . . . . . . . . . . . . . 341kontextsensitive . . . . . . . . . . . . . . . . . . . . 341reguläre . . . . . . . . . . . . . . . . . . . . . . . 341, 353
Sprachtypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
stabiler Zustand . . . . . . . . . . . . . . . . . . . . . . . . . 331Standardausgabe . . . . . . . . . . . . . . . . . . . . . . . . . 70Standardbibliothek . . . . . . . . . . . . . . . . . . . . . . 220Startsymbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Startvariable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364statische Methode . . . . . . . . . . . . . . . . . . . . 89, 181Stereotyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257Steuerungs-Befehl . . . . . . . . . . . . . . . . . . . . . . . 314Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
strictfp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364String . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184, 202struct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224Struktogramm . . . . . . . . . . . . . . 30, 31, 33, 34, 73Subklasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157Suchbaum
binärer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . 114binäre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290des Minimums . . . . . . . . . . . . . . . . . . . . . . 47in einem Array . . . . . . . . . . . . . . . . . . . . . 123in einem Datenbestand . . . . . . . . . 113, 125in verzeigerten linearen Listen . . . . . . . 132
Summe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
STICHWORTVERZEICHNIS 391
super . . . . . . . . . . . . . . . . . . . . 160, 174, 207, 364Superklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191, 208
Komponenten . . . . . . . . . . . . . . . . . . . . . . 192swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364synchronized . . . . . . . . . . . . . . . . . . . . . . . . . 364Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337Syntaxdiagramm . . . . . . . . . . . . . . . . . . . . . 39, 142
erweitert . . . . . . . . . . . . . . . . . . . . . . . . . . 168
System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184System.exit(0) . . . . . . . . . . . . . . . . . . . . . . 202System.in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184System.out . . . . . . . . . . . . . . . . . . . . . . . . . . . 184System.out.println . . . . . . . . . . . . . . 70, 183Systementwurf . . . . . . . . . . . . . . . . . . . . . . . . . . 149Systemzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
T
Tabellendarstellung . . . . . . . . . . . . . . . . . . . . . . 323Takt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333Taktgeber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332Tastatureingabe . . . . . . . . . . . . . . . . . . . . . . . . . 184Tastenklick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198Teilbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298Terminalzeichen . . . . . . . . . . . . . . . . . . . . . . . . 340Terminierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17theoretische Informatik . . . . . . . . . . . . . . . . . . . 10this . . . . . . . . . . . . . . . . . . . . . 173, 174, 198, 364throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364Titelzeile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194Top-Down-Strategie . . . . . . . . . . . . . . . . . . . . . . 19Top-Level-Container . . . . . . . 193, 195, 197, 199
transient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364Transistor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319Transport-Befehl . . . . . . . . . . . . . . . . . . . . . . . . 314true . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184, 364try-catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352Turingmaschinen
bandbeschränkte . . . . . . . . . . . . . . . . . . . 349deterministische . . . . . . . . . . . . . . . . . . . . 350nichtdeterministische . . . . . . . . . . . . . . . 349
Typ Applikation . . . . . . . . . . . . . . . . . . . . . . . . . 119
Type Casting . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165typedef . . . . . . . . . . . . . . . . . . . . . . . . . . 223, 254Typkonvertierung . . . . . . . . 63, 64, 164, 166, 212
explizite . . . . . . . . . . . . . . . . . . . 64, 165, 166implizite . . . . . . . . . . . . . . . . . . . . . . 164, 166implizite (automatische) . . . . . . . . . . . . 166
U
Überführungsfunktion . . . . . . . . . . . . . . . . . . . 353Übergabeparameter . . . . . . . . . . . . . . . . . . . . . . . 71Überladen . . . . . . . . . . . . . . . . . . . . . . . . . . 171, 173
Überladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170Überschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Überschreibung . . . . . . . . . . . . . . . . . . . . . . . . . 170Übersetzung . . . . . . . . . . . . . . . . . . . . . . . . 221, 344
Übersetzungsprozess . . . . . . . . . . . . . . . . 146, 244Übertrag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328UML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143, 154
Anwendungsfalldiagramm . . . . . . . . . . 251Diagramm-Vererbungshierachie . . . . . 157Diagramme . . . . . . . . . . . . . . . . . . . . . . . . 249
Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 253Klassendiagramm . . . . . . . . . . . . . . . . . . 155
Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Sequenzdiagramm. . . . . . . . . . . . . . . . . . 260Unified Modeling Language . . . . . . . . . 250Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . 254
und . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 323Verknüpfung . . . . . . . . . . . . . . . . . . . . . . . . 60
UnicodeZeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Unified Modeling Language . . . . . . . . . . . . . . 155unmittelbare Ableitung . . . . . . . . . . . . . . 339, 340unsigned . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223Unterklasse . . . . . . . . . . . . . . . . . . . . . . . . 157, 161
Deklaration . . . . . . . . . . . . . . . . . . . 157, 162
Instantiierung . . . . . . . . . . . . . . . . . . . . . . 164
util . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
V
Variable . . . . . . . . . . . . . . . . . . . . . . . . . . 26, 27, 49
392 STICHWORTVERZEICHNIS
Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . 126Variablendeklaration . . . . . . . . . . . . . . . 46, 49, 50
mit Wertzuweisung . . . . . . . . . . . . . . . . . . 51
Variablenname . . . . . . . . . . . . . . . . . . . . . . . . . . . 28Variablenzeichen . . . . . . . . . . . . . . . . . . . . . . . . 339Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211Verallgemeinerung . . . . . . . . . . . . . . . . . . . . . . 161Verdecken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Vererbung . . . . . . . . . . . . 156, 161, 202, 242, 255Vererbungshierachie
UML-Diagramm . . . . . . . . . . . . . . . . . . . 157Vererbungshierarchie . . . . . . . . . . . . . . . . . . . . 156Vererbungssichtbarkeit . . . . . . . . . . . . . . . . . . . 169Vergleich
arithmetischer . . . . . . . . . . . . . . . . . . . . . . . 60
Vergleichsoperator . . . . . . . . . . . . . . . . . . . . . . . . 60Verifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Verkettung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70Verknüpfungsregel . . . . . . . . . . . . . . . . . . . . . . . 60Verweis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126verzeigerte lineare Liste . . . . . . . . . . . . . . . . . . 132Virtuelle Java Maschine (Java VM) . . . . . . . . . 44Visual C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217void . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119, 364volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364vollständige Induktion . . . . . . . . . . . . . . . 277, 293
Beweis . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277Beweisprinzip . . . . . . . . . . . . . . . . . . . . . 280
Induktionsanfang . . . . . . . . . . . . . . . . . . . 293Induktionsschritt . . . . . . . . . . . . . . . . . . . 293
von-Neumann. . . . siehe von-Neumann-Rechnervon-Neumann-Rechner . . . . . . . . . . . . . . . . . . 313
W
Wahrheitswert . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Wertzuweisung . . . . . . . . . . . . . 26, 28, 47, 50, 51an eine Objektvariable . . . . . . . . . . . . . . 127an eine Variable . . . . . . . . . . . . . . . . . . . . . 51
an eine Variable primitiven Datentyps 128while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364while-Schleife . . . . . . . . . . . . . . . . . . . . . . . 68, 124width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179, 208
Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193Wirkung
eindeutige . . . . . . . . . . . . . . . . . . . . . . . . . . 17worst-case-Aufwand . . . . . . . . . . . . . . . . . . . . . 266worst-case-Zeitaufwand . . . . . . . . . . . . . . . . . . 304Wort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337, 340
akzeptieren . . . . . . . . . . . . . . . . . . . . . . . . 353
leeres . . . . . . . . . . . . . . . . . . . . . . . . . 339, 340Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . 342reserviertes . . . . . . . . . . . . . . . . . . . . . . . . 361
Wurzel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Y
YEAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Z
Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52, 54
Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . 126, 230, 231Zeitaufwand . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Analyse . . . . . . . . . . . . . . . . . . . . . . . 265, 271asymptotischer . . . . . . . . . . . . . . . . . . . . . 294binäre Suche . . . . . . . . . . . . . . . . . . . . . . . 293binärer Suchbaum . . . . . . . . . . . . . . . . . . 301Hashing . . . . . . . . . . . . . . . . . . . . . . 303, 305Menge . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287sortierendes Array . . . . . . . . . . . . . . . . . . 292sortiertes Array . . . . . . . . . . . . . . . . . . . . 301unsortiertes Array . . . . . . . . . . . . . . . . . . 301worst-case- . . . . . . . . . . . . . . . . . . . . . . . . 304
Zielsprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344Zustand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
stabiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331Zustandsübergangsdiagramm . . . . . . . . . . . . . 350Zustandsdiagramm . . . . . . . . . . . . . . . . . . . . . . 352Zuweisungs
Befehl . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314Kompatibilität . . . . . . . . . . . . . . . . . 164, 166
zweiwertige Informationsdarstellung. . 319, 321
Recommended