Anhang978-3-658-16141...362 A Schlüsselwörter im Sprachumfang von Java Befehl Bedeutung catch Ausnahme (Exception) catch (eineException e) {...}) char primitiver Datentyp char vat

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-


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“


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.


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)


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 [email protected] gesandtwerden. Über den Menüpunkt „Finish“ wird der Dialog geschlossen.


(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


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-


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.


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


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


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


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


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


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


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


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


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


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

Documents

Anhang978-3-658-16141...362 A Schlüsselwörter im Sprachumfang von Java Befehl Bedeutung catch Ausnahme (Exception) catch (eineException e) {...}) char primitiver Datentyp char vat