Title: i10_Haehn
Tags: I10

Q: [latex]\centering\sloppy Guter Programmierstil[/latex]
A: [latex]\centering\sloppy Einhaltung folgender Konventionen beim Schreiben von Programmen: \begin{inlineenumerate} \item Sorgf\IeC {\"a}ltige Planung von Abl\IeC {\"a}ufe und Strukturen, zum Beispiel mit UML \item \IeC {\"U}bersichtliche und nachvollziehbare Codegestaltung \item Programmdokumentation, zum Beispiel mit Doc-Kommentaren \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Attribut[/latex]
A: [latex]\centering\sloppy Eigenschaft eines Objektes[/latex]

Q: [latex]\centering\sloppy Attributwert[/latex]
A: [latex]\centering\sloppy Auspr\IeC {\"a}gung der Eigenschaft (Attribut) eines Objekts[/latex]

Q: [latex]\centering\sloppy Zustand (eines Objekts)[/latex]
A: [latex]\centering\sloppy Gesamtheit aller Attributwerte eines Objekts[/latex]

Q: [latex]\centering\sloppy Algorithmus[/latex]
A: [latex]\centering\sloppy Endliche, wohlbestimmte Abfolge von Anweisungen[/latex]

Q: [latex]\centering\sloppy Struktogramm[/latex]
A: [latex]\centering\sloppy Graphische Veranschaulichung eins Algorithmus mit Fokus auf imparativen Konzepten[/latex]

Q: [latex]\centering\sloppy Instanz (einer Klasse)[/latex]
A: [latex]\centering\sloppy Konkretes Objekt mit den in der Klasse spezifizierten Attributen (und zugewiesenen Attributwerten) und Methoden[/latex]

Q: [latex]\centering\sloppy Paket[/latex]
A: [latex]\centering\sloppy Sammlung zusammengeh\IeC {\"o}riger Klassen[/latex]

Q: [latex]\centering\sloppy Konvention: \par Paketbezeichner[/latex]
A: [latex]\centering\sloppy Kleinbuchstaben ohne Unterstrich und andere Sonderzeichen \par Abtrennen von Unterpaketen durch \gqq{\textcode{.}} \par\bigskip Beispiel:~\textcode{sag.informatik}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Klassenbezeichner[/latex]
A: [latex]\centering\sloppy Beschreibende, aussagekr\IeC {\"a}ftige Substantiv(folgen) mit Binnenmajuskeln, bei denen jeweils der erste Buchstabe gro\IeC {\ss } geschrieben wird \par\bigskip Beispiel:~\textcode{HalloWelt}[/latex]

Q: [latex]\centering\sloppy Absoluter und Relativer Klassenbezeichner[/latex]
A: [latex]\centering\sloppy Klassenbezeichner mit beziehungsweise ohne vorangestelltem Paketbezeichner \par\bigskip Beispiel:~\textcode{sag.informatik.HalloWelt} beziehungsweise \textcode{HalloWelt}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Bezeichner (variabler) Attribute[/latex]
A: [latex]\centering\sloppy Beschreibende, aussagekr\IeC {\"a}ftige Substantiv(folgen) mit Binnenmajuskeln, bei denen jeweils der erste Buchstabe klein geschrieben wird \par\bigskip Beispiel:~\textcode{helloWorld}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Bezeichner konstanter Attribute[/latex]
A: [latex]\centering\sloppy Beschreibende, aussagekr\IeC {\"a}ftige Substantiv(folgen) in Versalien, gegebenenfalls durch Unterstrich getrennt \par\bigskip Beispiel:~\textcode{HELLO\_WORLD}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Bezeichner tempor\IeC {\"a}rer Variable[/latex]
A: [latex]\centering\sloppy Einzelne Kleinbuchstaben abh\IeC {\"a}ngig vom Datentyp: \begin{inlineenumerate} \item \textcode{c} (char) \item \textcode{d} (double) \item \textcode{i}, \textcode{j}, \textcode{k} oder \textcode{l} (integer) \item \textcode{p}, \textcode{q}, \textcode{r} oder \textcode{s} (String) \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Methodenbezeichner[/latex]
A: [latex]\centering\sloppy Beschreibendes, aussagekr\IeC {\"a}ftiges Verb, gefolgt von Substantiv(folgen) mit Binnenmajuskeln, Kleinbuchstaben am Beginn \par Schlie\IeC {\ss }ende Argumentklammern \par\bigskip Beispiel:~\textcode{\cmethod{sayHello}{\cvar{Zeichenkette}}}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Test[/latex]
A: [latex]\centering\sloppy Zeichenkette \textcode{is}, gefolgt von Substantiv(folgen) mit Binnenmajuskeln, Kleinbuchstaben am Beginn \par Schlie\IeC {\ss }ende Argumentklammern \par\bigskip Beispiel:~\textcode{\cmethod{isHelloFriendly}{}}[/latex]

Q: [latex]\centering\sloppy Fluchtsymbolsequenz[/latex]
A: [latex]\centering\sloppy Schreibweise f\IeC {\"u}r nicht-druckbare Zeichen, zumeist durch einen R\IeC {\"u}ckw\IeC {\"a}rts gerichteten Schr\IeC {\"a}gstrich eingeleitet \par\bigskip Beispiel:~\textcode{\textbackslash n} (Zeilenwechsel)[/latex]

Q: [latex]\centering\sloppy whitespace[/latex]
A: [latex]\centering\sloppy Zusammenfassende Bezeichnung f\IeC {\"u}r Leerzeichen, Tabulatoren und Leerzeilen[/latex]

Q: [latex]\centering\sloppy W\IeC {\"o}rter (einer Programmiersprache)[/latex]
A: [latex]\centering\sloppy Folge von alphanumerischen Zeichen, die durch whitespace und Sonderzeichen getrennt werden[/latex]

Q: [latex]\centering\sloppy Reservierte W\IeC {\"o}rter (einer Programmiersprache)[/latex]
A: [latex]\centering\sloppy Liste von W\IeC {\"o}rtern mit besonderer Funktion in der Sprache, die nicht f\IeC {\"u}r Bezeichner verwendet werden d\IeC {\"u}rfen \par\bigskip Beispiel:~\textcode{\creserved{import}}[/latex]

Q: [latex]\centering\sloppy Bezeichner[/latex]
A: [latex]\centering\sloppy Eindeutiges Wort, mit dem Attribute, Klassen\slash Objekte oder Methoden benannt werden[/latex]

Q: [latex]\centering\sloppy Konvention: \par Projektverzeichnis[/latex]
A: [latex]\centering\sloppy Verzeichnis, das alle Dateien eines Projektes enth\IeC {\"a}lt \par\bigskip Verzeichnisname stimmt mit Projektbezeichner \IeC {\"u}berein[/latex]

Q: [latex]\centering\sloppy Konvention: \par Klassendatei[/latex]
A: [latex]\centering\sloppy Textdatei, die den Programmcode von genau einer Klasse enth\IeC {\"a}lt \par\bigskip Dateiname stimmt mit Klassenbezeichner \IeC {\"u}berein \par Dateiendung\slash -typ:~\textcode{*.java}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Paketverzeichnis[/latex]
A: [latex]\centering\sloppy Paket und Unterpaket(e) werden von links nach rechts in Verzeichnisse umgesetzt \par\bigskip Ein Paketverzeichnis enth\IeC {\"a}lt alle zugeh\IeC {\"o}rigen Klassendateien[/latex]

Q: [latex]\centering\sloppy Konvention: \par Kopf einer Klassendatei[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth}\ccode \slash\textasteriskcentered \ccr \mbox{ }\textasteriskcentered\ @(\#) \cvar{Modulbezeichner} \cvar{Version} \ccr \mbox{ }\textasteriskcentered\ctab\cvar{Datum} \coptional{\cvar{Programmbetreuer}} \ccr \mbox{ }\textasteriskcentered \ccr \mbox{ }\textasteriskcentered\ Copyright (c) \cvar{Jahr} \ccr \mbox{ }\textasteriskcentered\ctab\cvar{Inhaber der Kopierrechte} \ccr \mbox{ }\textasteriskcentered\slash \end{minipage}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Paketdeklaration einer Klassendatei[/latex]
A: [latex]\centering\sloppy \textcode{\creserved{package} \cvar{Paket}\coptional{.\cvar{Unterpaket}} ;}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Import einer Klasse[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth} \ccode\creserved{import} \ccr* \cvar{Paket}\coptional{.\cvar{Unterpaket}}.\cvar{Klasse} ; \end{minipage}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Programmcode einer Klasse[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \cvar{Klassendokumentation} \ccr \coptional{\cvar{Modifizierer}} \ccr* \creserved{class} \cvar{Klassenbezeichner} \{ \ccr \ctab\cvar{Programmcode} \ccr \} \end{quote}[/latex]

Q: [latex]\centering\sloppy Konvention: \par Aufbau einer Klassendatei[/latex]
A: [latex]\centering\sloppy Struktur in vier durch Leerzeilen getrennte Abschnitte: \begin{inlineenumerate} \item Dateikopf, ID, Kopierrechte als Blockkommentar \item Gegebenenfalls Paketdeklaration \item Gegebenenfalls Import weiterer Klassen \item Programmcode der Klasse \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Sichtbarkeitsmodifikator[/latex]
A: [latex]\centering\sloppy Schl\IeC {\"u}sselwort der Sprache, welches den Umfang des Zugriffs auf ein Element regelt[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Sichtbarkeit \textcode{\creserved{public}}[/latex]
A: [latex]\centering\sloppy Auf das entsprechende Element kann von Au\IeC {\ss }en (uneingeschr\IeC {\"a}nkt) zugegriffen werden \par\bigskip Kennzeichnung im UML-Diagramm durch dem Bezeichner vorangestelltes~\gqq{\textcode{+}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Sichtbarkeit \textcode{\creserved{private}}[/latex]
A: [latex]\centering\sloppy Das entsprechende Element ist von Au\IeC {\ss }en nicht sichtbar \par\bigskip Kennzeichnung im UML-Diagramm durch dem Bezeichner vorangestelltes~\gqq{\textcode{-}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Kommentar[/latex]
A: [latex]\centering\sloppy Sprachkonstruktion, die vom \IeC {\"U}bersetzer ignoriert wird[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Einfacher Kommentar[/latex]
A: [latex]\centering\sloppy Code, der zwischen einem doppelten Schr\IeC {\"a}gstrich und dem Ende der Zeile steht \par Verwendung f\IeC {\"u}r Erl\IeC {\"a}uterungen oder Markieren wichtiger Stellen \par\bigskip Beispiel:~\textcode{\slash\slash\ Kommentar}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Blockkommentar[/latex]
A: [latex]\centering\sloppy Code, der zwischen einem Schr\IeC {\"a}gstrich, direkt gefolgt von einem Stern und einem Stern direkt gefolgt von einem Schr\IeC {\"a}gstrich steht \par Verwendung zum Auskommentieren von Quellcode \par\bigskip Beispiel:~\textcode{\slash\textasteriskcentered\ Blockkommentar \textasteriskcentered\slash}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar[/latex]
A: [latex]\centering\sloppy Spezieller Blockkommentar, der mit einem Schr\IeC {\"a}gstrich direkt gefolgt von zwei Sternen beginnt \par Verwendung zur Dokumentation mindestens aller Code-Elemente der Sichtbarkeit \textcode{\creserved{public}} \par\bigskip Beispiel:~\textcode{\slash\textasteriskcentered\textasteriskcentered\ Doc-Kommentar \textasteriskcentered\slash}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Aufbau eines Doc-Kommentars[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item Kurzerl\IeC {\"a}uterung des dokumentierten Elements in einem Satz \item Optionale ausf\IeC {\"u}hrliche Beschreibung \item Folge von erforderlichen und optionalen Schl\IeC {\"u}sselw\IeC {\"o}rtern \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Kurzerl\IeC {\"a}uterung[/latex]
A: [latex]\centering\sloppy Charakterisierung des Elements in einem Satz, der durch einen Punkt und einen Zeilenwechsel beendet wird \par\bigskip Wird im \IeC {\"U}bersichtsteil der Dokumentation wiederholt und muss aussagekr\IeC {\"a}ftig und f\IeC {\"u}r sich verst\IeC {\"a}ndlich sein[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: ausf\IeC {\"u}hrliche Erkl\IeC {\"a}rung[/latex]
A: [latex]\centering\sloppy N\IeC {\"a}here Beschreibung des Elements: Funktion, Details der Schnittstelle oder Hinweise zur Verwendung[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Schl\IeC {\"u}sselwort \textcode{\cat version}[/latex]
A: [latex]\centering\sloppy \textcode{\cat version \cvar{major}.\cvar{minor}} (optional; Klassen) \par\bigskip Versionsangabe mit Hauptversion \cvar{major} und Unterversion \cvar{minor}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Schl\IeC {\"u}sselwort \textcode{\cat author}[/latex]
A: [latex]\centering\sloppy \textcode{\cat author \cvar{name}} (optional; Klassen) \par\bigskip Angabe des Programmauthors, bei mehreren Autoren muss f\IeC {\"u}r jeden Programmierer ein eigenener \textcode{@author}-Schl\IeC {\"u}ssel verwendet werden[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Schl\IeC {\"u}sselwort \textcode{\cat param}[/latex]
A: [latex]\centering\sloppy \textcode{\cat param \cvar{Bezeichner} \cvar{Beschreibung}} (zwingend; Konstruktoren, Methoden) \par\bigskip Beschreibung des Parameters \cvar{Bezeichner}, bei mehreren Parametern muss f\IeC {\"u}r jedes Argument ein eigener \textcode{@param}-Schl\IeC {\"u}ssel angegeben werden[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Schl\IeC {\"u}sselwort \textcode{\cat return}[/latex]
A: [latex]\centering\sloppy \textcode{\cat return \cvar{Datentyp}} (zwingend; Methoden) \par\bigskip Angabe des Typs des R\IeC {\"u}ckgabewertes, falls dieser nicht \textcode{void} ist[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Schl\IeC {\"u}sselwort \textcode{\cat exception}[/latex]
A: [latex]\centering\sloppy \textcode{\cat exception \cvar{Bezeichner} \cvar{Beschreibung}} (zwingend; Konstruktoren, Methoden) \par\bigskip Beschreibung der Ausnahmebehandlung \cvar{Bezeichner}, falls die Methode eine solche Ausnahme abf\IeC {\"a}ngt[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Doc-Kommentar: Schl\IeC {\"u}sselwort \textcode{\cat see}[/latex]
A: [latex]\centering\sloppy \textcode{\cat see \cvar{link}} (optional; Klassen, Konstruktoren, Methoden, Attribute) \par\bigskip Verweis auf andere Programmteile[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Variable[/latex]
A: [latex]\centering\sloppy Auch: Attribut \par\bigskip Benannter Speicherplatz zur Aufnahme von Daten[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Attribut[/latex]
A: [latex]\centering\sloppy Auch: Variable \par\bigskip Benannter Speicherplatz zur Aufnahme von Daten[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration[/latex]
A: [latex]\centering\sloppy Vergabe eines Bezeichners, Festlegung des Datentyps und die Reservierung des Speicherplatzes[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Attributdeklaration[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \coptional{\cvar{Modifizierer}} \cvar{Datentyp} \ccr* \cvar{Attributbezeichner} \ccr* \coptional{\cvar{Zuweisung}} ; \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Konstante[/latex]
A: [latex]\centering\sloppy Attribut, dessen Wert unver\IeC {\"a}nderlich ist \par\bigskip Deklaration durch das Schl\IeC {\"u}sselwort \textcode{\creserved{final}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Schl\IeC {\"u}sselwort \textcode{\creserved{static}}[/latex]
A: [latex]\centering\sloppy Kennzeichnen eines Elementes als unabh\IeC {\"a}ngig von der Existenz eines Objektes (statisch)[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Datentyp \textcode{int}[/latex]
A: [latex]\centering\sloppy Vorzeichenbehaftete ganze Zahl \par\bigskip Beispiel:~\textcode{123}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Datentyp \textcode{double}[/latex]
A: [latex]\centering\sloppy Vorzeichenbehaftete Gleitkommazahl \par\bigskip Beispiel:~\textcode{1.2345}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Datentyp \textcode{boolean}[/latex]
A: [latex]\centering\sloppy Wahrheitswert \par\bigskip Beispiel:~\textcode{\creserved{true}} oder \textcode{\creserved{false}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Datentyp \textcode{char}[/latex]
A: [latex]\centering\sloppy Einzelzeichen des Unicode-Zeichensatzes \par\bigskip Beispiel:~\textcode{\cquote c\cquote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Datentyp \textcode{String}[/latex]
A: [latex]\centering\sloppy Zeichenkette \par\bigskip Beispiel:~\textcode{\cquotes abcd\cquotes}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Angabe eines Attributs im UML-Diagramm[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth} \textcode{\coptional{+ \calternate - \calternate \#} \cattribute[type=\cvar{Datentyp}]{\cvar{Attributbezeichner}\ccr*}} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Zuweisung[/latex]
A: [latex]\centering\sloppy Speichern eines Attributwertes \par\bigskip Vor der Zuweisung ist die Deklaration zwingend erforderlich[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Zuweisung an ein Attribut[/latex]
A: [latex]\centering\sloppy \textcode{\cvar{Attributbezeichner} = \cvar{Wert} ;}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Zuweisungsoperator[/latex]
A: [latex]\centering\sloppy Ein einzelnes Gleichheitszeichen \textcode{=}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Nullwert[/latex]
A: [latex]\centering\sloppy Spezieller, typenloser Attributwert mit der Bedeutung \gqq{kein Wert}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Attributwert \textcode{\creserved{null}}[/latex]
A: [latex]\centering\sloppy \gqq{Kein Wert} \par\bigskip Der Nullwert ist typenlos[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Initialisierung[/latex]
A: [latex]\centering\sloppy Erste Zuweisung an ein Attribut \par\bigskip Primitive Datentypen werden bereits bei der Deklaration initialisiert[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Voreinstellungen bei der Initialisierung von Attributen mit primitivem Datentyp[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item \textcode{int} --- Attributwert \textcode{0} \item \textcode{double} --- Attributwert \textcode{0.0} \item \textcode{boolean} --- Attributwert \textcode{\creserved{false}} \item \textcode{char} --- Attributwert \textcode{\textbackslash u000} (Nullbyte) \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Voreinstellung bei der Initialisierung von Attributen mit einem Referenztyp als Datentyp[/latex]
A: [latex]\centering\sloppy \textcode{\creserved{null}} \par\bigskip Sie verweisen auf kein Objekt[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Casting[/latex]
A: [latex]\centering\sloppy Umwandlung eines Datentyps in einen anderen \par\bigskip Implizites (automatisches) Casting durch den \IeC {\"U}bersetzer \par Explizites (gefordertes) Casting durch den Programmierer[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Explizites Casting[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth} \textcode{\cvar{Attributbezeichner} \ccr* = (\cvar{Datentyp}) \cvar{Attributwert} ;} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Implizites Casting[/latex]
A: [latex]\centering\sloppy \textcode{char} $\rightarrow$~\textcode{int} $\rightarrow$~\textcode{double} $\rightarrow$~\textcode{String} \par\bigskip \textcode{boolean}~$\rightarrow$ \textcode{String}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Anweisung[/latex]
A: [latex]\centering\sloppy Auch: statement \par\bigskip Einzelner Arbeitsschritt innerhalb einer Sequenz \par\bigskip Abschluss einer Anweisung in Java durch \textcode{;}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par statement[/latex]
A: [latex]\centering\sloppy Auch: Anweisung \par\bigskip Einzelner Arbeitsschritt innerhalb einer Sequenz \par\bigskip Abschluss einer Anweisung in Java durch \textcode{;}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Sequenz[/latex]
A: [latex]\centering\sloppy Folge von Anweisungen[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Block[/latex]
A: [latex]\centering\sloppy Folge von Anweisungen, die durch Klammerung zusammengefasst und als eine Anweisung verarbeitet werden \par\bigskip \begin{quote}\ccode \{ \cvar{Anweisung} \ccr \ctab\cvar{Anweisung} \ccr \} \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Operator[/latex]
A: [latex]\centering\sloppy $n$-stellige Funktion, die in Infix-Notation gesetzt wird \par\bigskip Beispiele: \textcode{+}, \textcode{==} oder \textcode{\&\&}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Inkrement[/latex]
A: [latex]\centering\sloppy Erh\IeC {\"o}hung einer Variable vom Datentyp \textcode{int} um~$1$ \par\bigskip Beispiel:~\textcode{cnt++}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Dekrement[/latex]
A: [latex]\centering\sloppy Verminderung einer Variable vom Datentyp \textcode{int} um~$1$ \par\bigskip Beispiel:~\textcode{cnt-{}-}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Arithmetische Operatoren[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item \textcode{+} und \textcode{-} (un\IeC {\"a}r als Vorzeichen, bin\IeC {\"a}r als Summe) \item \textcode{\textasteriskcentered} und \textcode{/} (Multiplikation und Division) \item \textcode{\%} (ganzzahliger Rest) \item \textcode{++} und \textcode{-{}-} (Inkrement und Dekrement) \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Konjunktion[/latex]
A: [latex]\centering\sloppy Logische Funktion \gqq{Und zugleich} \par\bigskip Ergibt genau dann den Wert \textcode{\creserved{true}}, wenn alle Argumente den Wert \textcode{\creserved{true}} haben[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Disjunktion[/latex]
A: [latex]\centering\sloppy Logische Funktion \gqq{Oder} \par\bigskip Ergibt genau dann den Wert \textcode{\creserved{true}}, wenn ein Argument den Wert \textcode{\creserved{true}} hat[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Logische Operatoren[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item \textcode{==} (Vergleich: Gleichheit) \item \textcode{<}, \textcode{<=}, \textcode{>=} und \textcode{>} (Vergleich: kleiner, kleiner oder gleich, gr\IeC {\"o}\IeC {\ss }er, gr\IeC {\"o}\IeC {\ss }er oder gleich) \item \textcode{!=} (Vergleich: Ungleichheit) \item \textcode{!} (Gegenteil: Nicht) \item \textcode{\&\&} (Konjunktion) \item \textcode{||} (Disjunktion) \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Konkatenation (von Zeichenketten)[/latex]
A: [latex]\centering\sloppy Aneinanderf\IeC {\"u}gen von Zeichenketten \par\bigskip Operatorsymbol:~\textcode{+} \par\bigskip Beispiel:~\textcode{\cquotes Hallo\cquotes + \cquotes Welt\cquotes} ergibt \textcode{\cquotes HalloWelt\cquotes}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Prozedur[/latex]
A: [latex]\centering\sloppy Benannte Sequenz \par\bigskip Die Anweisungen der Prozedur bilden einen Block und k\IeC {\"o}nnen durch Angabe des Prozedurbezeichners aufgerufen werden[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Seiteneffekt[/latex]
A: [latex]\centering\sloppy Ver\IeC {\"a}nderungen am Zustand des Objekts, die durch den Aufruf einer Methode entstehen[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Funktion[/latex]
A: [latex]\centering\sloppy Prozedur, die einer Reihe von Eingabedaten genau ein Ausgabedatum zuordnet[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par R\IeC {\"u}ckgabewert einer Funktion[/latex]
A: [latex]\centering\sloppy Ausgabedatum der Funktion \par\bigskip Der Datentyp des R\IeC {\"u}ckgabewertes bestimmt den R\IeC {\"u}ckgabetyp der Methode[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Methode[/latex]
A: [latex]\centering\sloppy Funktion eines Objektes \par oder Funktion einer Klasse, falls die Methode als statiscch deklariert ist[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Methodendeklaration[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth}\ccode \coptional{\cvar{Modifizierer}} \cvar{R\IeC {\"u}ckgabetyp} \ccr* \cvar{Bezeichner} (\cvar{Parameterliste}) \{ \ccr \ctab\cvar{Methodenrumpf} \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Signatur einer Methode[/latex]
A: [latex]\centering\sloppy Kombination aus Methodenbezeichner, Anzahl und Datentyp der Parameter \par\bigskip Innerhalb einer Klasse d\IeC {\"u}rfen zwei Methoden nicht die gleiche Signatur aufweisen[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par \IeC {\"U}berladen einer Methode[/latex]
A: [latex]\centering\sloppy Deklaration einer Methode, die sich von einer anderen Methode (mit dem selben Namen) nur in Anzahl und\slash oder Datentyp der Parameter unterscheidet[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Methodenrumpf[/latex]
A: [latex]\centering\sloppy Prozedur der Anweisungen, die beim Aufruf der Methode ausgef\IeC {\"u}hrt werden \par\bigskip Der Methodenrumpf ist ein benannter Block[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Anweisung \textcode{\cmethod{return}{\cvar{Wert}} ;}[/latex]
A: [latex]\centering\sloppy statement, das eine Methode beendet und \cvar{Wert} als Ausgabedatum der Methode festlegt \par\bigskip Der Datentyp von \cvar{Wert} bestimmt den R\IeC {\"u}ckgabetyp der Methode[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Datentyp \textcode{\creserved{void}}[/latex]
A: [latex]\centering\sloppy \gqq{Kein Wert} \par\bigskip R\IeC {\"u}ckgabetyp f\IeC {\"u}r Methoden, die keinen R\IeC {\"u}ckgabewert liefern (Prozeduren)[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java):: \par Angabe einer Methode im UML-Diagramm[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth}\ccode \coptional{+ \calternate - \calternate \#} \cmethod[type=\cvar{Datentyp}]{\cvar{Bezeichner}}{ \ccr* \cmultiple{\cattribute[type=\cvar{Datentyp}]{\cvar{Parameter}}} \ccr} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java):: \par Empfehlung f\IeC {\"u}r das Schreiben von Methoden[/latex]
A: [latex]\centering\sloppy Schreiben Sie nachvollziehbare Programme und vermeiden Sie Seiteneffekte![/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Objektdaten[/latex]
A: [latex]\centering\sloppy Zustand des Objekts: Gesamtheit der Attributwerte[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Objektfunktionalit\IeC {\"a}t[/latex]
A: [latex]\centering\sloppy Methodenspektrum eines Objekts[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Schnittstelle (eines Objekts)[/latex]
A: [latex]\centering\sloppy Gesamtheit der Signaturen eines Objekts als Zusicherung eines definierten Objektverhaltens unabh\IeC {\"a}ngig von der Methodenimplementierung[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Prinzip der Datenkapselung[/latex]
A: [latex]\centering\sloppy Selbstverwaltung seiner Attribute durch ein Objekt \par\bigskip direkter Zugriff auf Objektattribute von Au\IeC {\ss }en nicht erlaubt: \begin{inlineenumerate} \item Attributsichtbarkeit \textcode{\creserved{private}} \item get\slash set-Methoden \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Kanonische Methode zur R\IeC {\"u}ckgabe eines Attributwerts (\gqq{Getter})[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth}\small\ccode \begin{doccomment} R\&uuml;ckgabe von \makebox[0pt][l]{\cvar{Attributbezeichner}.} \ccr\ccr @see \cvar{Attributbezeichner} \end{doccomment} \ccr \creserved{public} \cvar{Datentyp} get\cvar{Attributbezeichner} \ccr* () \{ \ccr \ctab return(\cvar{Attributbezeichner}) ; \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Kanonische Methode zur Zuweisung eines Werts an ein Attribut (\gqq{Setter})[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth}\small\ccode \begin{doccomment} Zuweisung an \cvar{Attributbezeichner}. \ccr\ccr @param x Attributwert \ccr @see \cvar{Attributbezeichner} \end{doccomment} \ccr \creserved{public} \creserved{void} set\cvar{Attributbezeichner} \ccr* (\cvar{Datentyp} x) \{ \ccr \ctab \cvar{Attributbezeichner} = x ; \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Kontrollstruktur[/latex]
A: [latex]\centering\sloppy Anweisungen, die den Ablauf der Anweisungfolge einer Sequenz ver\IeC {\"a}ndert \par\bigskip Beispiele: Wiederholungsanweisungen oder Schleifen, Entscheidungsanweisungen[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Wiederholungsanweisung[/latex]
A: [latex]\centering\sloppy Kontrollstruktur, die zur mehrfachen Ausf\IeC {\"u}hrung einer Anweisung oder eines Blocks f\IeC {\"u}hrt[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Entscheidungsanweisung[/latex]
A: [latex]\centering\sloppy Kontrollstruktur, die die Ausf\IeC {\"u}hrung einer Anweisung oder eines Blockes von einer Bedingung abh\IeC {\"a}ngig macht[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Test[/latex]
A: [latex]\centering\sloppy Methode, deren R\IeC {\"u}ckgabewert vom Datentyp \textcode{boolean} ist \par\bigskip Beispiel: \textcode{\cmethod{istPositiv}{}} mit \par \begin{quote}\ccode istPositiv(int i) \{ \ccr \ctab return(i > 0) ; \ccr \} \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Code f\IeC {\"u}r eine Schleife mit Anfangsbedingung[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \creserved{while} (\cvar{Bedingung}) \{ \ccr \ctab\cvar{Schleifenk\IeC {\"o}rper} \ccr \} ; \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Code f\IeC {\"u}r eine bedingte Anweisung[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \creserved{if} (\cvar{Bedingung}) \{ \ccr \ctab\cvar{Anweisungen wahr-Fall} \ccr \} \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Code f\IeC {\"u}r eine zweiseitige Auswahl[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \creserved{if} (\cvar{Bedingung}) \{ \ccr \ctab\cvar{Anweisungen wahr-Fall} \ccr \} \creserved{else} \{ \ccr \ctab\cvar{Anweisungen falsch-Fall} \ccr \} \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Konstruktor[/latex]
A: [latex]\centering\sloppy Methode zur Initialisierung eines Objekts \par\bigskip Bezeichner von Klasse und Konstruktor m\IeC {\"u}ssen identisch sein[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par \textcode{\creserved{new}}-Operator[/latex]
A: [latex]\centering\sloppy Reserviertes Wort der Sprache zur Erzeugung eines Objekts \par\bigskip \textcode{\creserved{new} \cvar{Konstruktoraufruf}} \par\bigskip R\IeC {\"u}ckgabe ist eine Referenz auf das erzeugte Objekt[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Beispiel Objekterzeugung und Konstruktoraufruf[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode HalloWelt hello ; \ccr hello = \creserved{new} HalloWelt() \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Modifizierer~\textcode{\creserved{static}}[/latex]
A: [latex]\centering\sloppy Deklaration eines Elements als statisch \par\bigskip Statische Elemente existieren unabh\IeC {\"a}ngig von der Existenz eines Objekts \par\bigskip Beispiele: \textcode{Math.PI}, \textcode{\cmethod{main}{}}[/latex]

Q: [latex]\centering\sloppy Konventionen f\IeC {\"u}r \IeC {\"u}bersichtlichen Code (Java): \par Leerzeichen[/latex]
A: [latex]\centering\sloppy {\small Leerzeichen \begin{inlineenumerate} \item trennen Bezeichner\slash W\IeC {\"o}rter und Klammern\slash W\IeC {\"o}rter\slash\ Bezeichner \item bin\IeC {\"a}re Operatoren und Argumente \item folgen Kommata\slash Strichpunkten. \end{inlineenumerate} \par Nicht zwischen Methodenbezeichner und Argumentklammer, un\IeC {\"a}rem Operator und Argument, vor Punktoperator, nach \IeC {\"o}ffnender, vor schlie\IeC {\ss }ender Klammer}[/latex]

Q: [latex]\centering\sloppy Konventionen f\IeC {\"u}r \IeC {\"u}bersichtlichen Code (Java): \par Leerzeilen, Einzug und Zeilenwechsel[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item Anweisungen beginnen eine Zeile \item Sequenzen durch Leerzeilen trennen \item Einzug in jeder Ebene vier Zeichen \item Zeilenl\IeC {\"a}nge h\IeC {\"o}chstens 80~Zeichen, sinnvolle Zeilenwechsel, Fortsetzungzeilen mit Einzug \item Niemals \IeC {\"o}ffnende geschweifte Klammer in einer eigenen Zeile \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Feld[/latex]
A: [latex]\centering\sloppy Auch: Array \par\bigskip Attribut, das eine Folge von Attributen gleichen Datentyps (Feldelemente) enth\IeC {\"a}lt, die \IeC {\"u}ber Indizes nummeriert werden[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Array[/latex]
A: [latex]\centering\sloppy Auch: Feld \par\bigskip Attribut, das eine Folge von Attributen gleichen Datentyps (Feldelemente) enth\IeC {\"a}lt, die \IeC {\"u}ber Indizes nummeriert werden[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par L\IeC {\"a}nge eines Feldes[/latex]
A: [latex]\centering\sloppy Anzahl der Feldelemente[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Felddeklaration[/latex]
A: [latex]\centering\sloppy \textcode{\coptional{\cvar{Modifizierer}} \ccr* \cvar{Datentyp}[] \cvar{Feldbezeichner} ;}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Feldinitialisierung[/latex]
A: [latex]\centering\sloppy \textcode{\cvar{Feldbezeichner} \ccr* = \creserved{new} \cvar{Datentyp}[\cvar{Anzahl}] ;} \par\bigskip Feldl\IeC {\"a}nge~\cvar{Anzahl} ist nach der Initialisierung konstant[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Feldelement[/latex]
A: [latex]\centering\sloppy Einzelnes Attribut aus der Folge aller Attribute eines Feldes \par\bigskip Zugriff \IeC {\"u}ber Indizes \textcode{\cvar{Feldbezeichner}[0]}, \textcode{\cvar{Feldbezeichner}[1]}\dots[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Referenz[/latex]
A: [latex]\centering\sloppy Verweis auf ein Objekt \par\bigskip Ist der Datentyp eines Attributs ein Referenztyp, so besteht der Attributwert aus einer Referenz und nicht dem Objekt selbst[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Referenztyp[/latex]
A: [latex]\centering\sloppy Datentyp eines Attribut, der durch eine Klasse gegeben ist \par\bigskip Gegenteil: primitiver Datentyp[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Primitiver Datentyp[/latex]
A: [latex]\centering\sloppy Einer der folgenden Datentypen: \textcode{int}, \textcode{double}, \textcode{float}, \textcode{char}, \textcode{boolean} \par\bigskip Gegenteil: Referenztyp[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Wert\IeC {\"u}bergabe[/latex]
A: [latex]\centering\sloppy Auch: \gqq{call by value} \par\bigskip Ersetzen eines Attributbezeichners durch den aktuellen Wert in folgenden Situationen: \begin{inlineenumerate} \item Auswertung eines Ausdrucks \item rechte Seite in einer Zuweisung \item Parameter\IeC {\"u}bergabe von Methoden \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Referenz\IeC {\"u}bergabe[/latex]
A: [latex]\centering\sloppy Auch: \gqq{call by reference} \par\bigskip Ersetzen eines Attributbezeichners durch eine Referenz auf das Wertobjekt \par\bigskip In Java gibt es kein \gqq{call by reference} --- h\IeC {\"o}chstens ein \gqq{call \emph{of} a reference}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Lokales Attribut[/latex]
A: [latex]\centering\sloppy Attribut, das innerhalb eines Blocks deklariert wird \par\bigskip Ein Zugriff au\IeC {\ss }erhalb des Blocks auf ein lokales Attribut erzeugt einen Fehler[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Globales Attribut[/latex]
A: [latex]\centering\sloppy Attribut, das nicht innerhalb eines Blocks deklariert wird \par\bigskip Der Zugriff auf ein globales Attribut ist von jeder Position des Codes m\IeC {\"o}glich[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par \IeC {\"U}berdecken eines (globalen) Attributs[/latex]
A: [latex]\centering\sloppy Unm\IeC {\"o}glichkeit des Zugriffs auf ein globales Attribut durch Existenz eines lokalen Attributs mit gleichem Bezeichner im aktuellen Block[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Betriebssystem[/latex]
A: [latex]\centering\sloppy Sammlung von Programmen, die den Zugriff auf die Ressourcen des Rechners regelt, Prozesse startet, \IeC {\"u}berwacht und beendet und ihnen Rechenzeit zuteilt[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Systemaufruf zum Starten eines Java-Programmes[/latex]
A: [latex]\centering\sloppy \textcode{java \coptional{\cvar{JRE-Optionen}} \ccr* \cvar{Hauptklasse} \coptional{\cvar{Optionen}}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Paketstruktur[/latex]
A: [latex]\centering\sloppy Zusammenfassen aller Klassen eines Programmes oder eines Programmmoduls in einem Paket \par\bigskip \textcode{\cmethod{main}{}}-Methode in h\IeC {\"o}chstens einer Klasse[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Gliederung einer Klassendatei[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item Deklaration statischer Attribute \item Deklaration statischer Methoden \item Definition mindestens eines Konstruktors \item Deklaration der Objekt-Attribute \item Deklaration der Objekt-Methoden \item Gegebenenfalls Deklaration der \textcode{main}-Methode \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Standard-Eingabekanal[/latex]
A: [latex]\centering\sloppy M\IeC {\"o}glichkeit f\IeC {\"u}r ein Programm, Daten von anderen Prozessen zu lesen \par\bigskip \textcode{java.lang.System.in}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Standard-Ausgabekanal[/latex]
A: [latex]\centering\sloppy M\IeC {\"o}glichkeit f\IeC {\"u}r ein Programm, Daten f\IeC {\"u}r andere Prozesse zur Verf\IeC {\"u}gung zu stellen \par\bigskip \textcode{java.lang.System.out}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Standard-Fehlerkanal[/latex]
A: [latex]\centering\sloppy M\IeC {\"o}glichkeit f\IeC {\"u}r ein Programm, Fehlermeldungen und Ablaufinformationen zum eigenen Prozess zur Verf\IeC {\"u}gung zu stellen \par\bigskip \textcode{java.lang.System.err}[/latex]

Q: [latex]\centering\sloppy Benutzeroberfl\IeC {\"a}che[/latex]
A: [latex]\centering\sloppy Erscheinungsform von Ein- und Ausgabe sowie Pr\IeC {\"a}sentation des Verarbeitungsprozesses eines Programms, um Interaktion und Programmkontrolle zu erm\IeC {\"o}glichen[/latex]

Q: [latex]\centering\sloppy Graphische Benutzeroberfl\IeC {\"a}che[/latex]
A: [latex]\centering\sloppy Auch: graphical user interface (GUI) \par\bigskip Benutzeroberfl\IeC {\"a}che, die aus einer Reihe von Objekten, die mit Aktionen (Eingabeereignisse, etwa von der Tastatur oder Maus) zur Steuerung eines Programmes verkn\IeC {\"u}pft sind[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Ausnahmebehandlung im Fehlerfall[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \creserved{try} \{ \ccr \ctab \cvar{Programmcode} \ccr \} \creserved{catch}(\cvar{AusnahmeTyp} \ccr* \cvar{Objektbezeichner}) \{ \ccr \ctab \cvar{Ausnahmebehandlung} \ccr \} \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Code f\IeC {\"u}r eine Schleife mit Endbedingung[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \creserved{do} \{ \ccr \ctab\cvar{Schleifenk\IeC {\"o}rper} \ccr \} \creserved{while} (\cvar{Bedingung}) ; \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Code f\IeC {\"u}r eine Z\IeC {\"a}hlschleife[/latex]
A: [latex]\centering\sloppy \begin{quote}\ccode \creserved{for} (\cvar{Start} ; \cvar{Bedingung} ; \cvar{Schritt}) \{ \ccr \ctab\cvar{Schleifenk\IeC {\"o}rper} \ccr \} ; \end{quote}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Code f\IeC {\"u}r eine Mehrfachauswahl[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth}\scriptsize\ccode \creserved{switch} (\cvar{integerVariable}) \{ \ccr \creserved{case} 1: \ccr \creserved{case} 2: \ccr \ctab\cvar{Anweisungen 1-2-Fall}; \ccr \ctab \coptional{break ;} \ccr \creserved{case} 3: \ccr \ctab\cvar{Anweisungen 3-Fall}; \ccr \ctab \coptional{break ;} \ccr \creserved{default}: \ccr \ctab\cvar{Anweisungen default-Fall}; \ccr \ctab \coptional{break ;} \ccr \} ; \end{minipage}[/latex]

Q: [latex]\centering\sloppy Kurzcharakterisierung einer objektorientierten Sprache[/latex]
A: [latex]\centering\sloppy Umsetzung der Grunds\IeC {\"a}tze \begin{inlineenumerate} \item Datenkapselung \item Vererbung \item Polymorphismus \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Einzige Verantwortung[/latex]
A: [latex]\centering\sloppy Auch: divide and conquer \par\bigskip Jedes Modul hat genau eine Aufgabe oder Verantwortung \par Jede Aufgabe wird von genau von einem Modul ausgef\IeC {\"u}hrt[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Trennung der Anliegen[/latex]
A: [latex]\centering\sloppy Auch: separation of concerns \par\bigskip Verschiedene Funktionen eines Programms (zum Beispiel Anwendungslogik und Benutzerschnittstelle) werden von verschiedenen Modulen erf\IeC {\"u}llt[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Vermeidung von Wiederholung[/latex]
A: [latex]\centering\sloppy Auch: don't repeat yourself \par\bigskip Jede Funktionalit\IeC {\"a}t sollte nur einmal implementiert werden[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Offenheit gegen\IeC {\"u}ber Erweiterungen[/latex]
A: [latex]\centering\sloppy Auch: open closed principle \par\bigskip Zus\IeC {\"a}tzliche Funktionen eines Moduls sollen erg\IeC {\"a}nzt werden k\IeC {\"o}nnen, ohne dass \IeC {\"A}nderungen am Ursprungsmodul n\IeC {\"o}tig werden[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Trennung von Schnittstelle und Implementierung[/latex]
A: [latex]\centering\sloppy Auch: program to interfaces \par\bigskip Funktionalit\IeC {\"a}t eines Moduls wird durch seine Schnittstelle beschrieben \par Jedes Modul soll unabh\IeC {\"a}ngig von der konkreten Implementierung durch ein anderes Modul bleiben[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Umkehr von Abh\IeC {\"a}ngigkeiten[/latex]
A: [latex]\centering\sloppy Auch: dependency inversion prinziple \par\bigskip Abh\IeC {\"a}ngigkeiten zwischen Modulen sollen sich nicht auf Spezialf\IeC {\"a}lle st\IeC {\"u}tzen[/latex]

Q: [latex]\centering\sloppy Prinzip objektorientierter Modellierung: \par Testbarkeit[/latex]
A: [latex]\centering\sloppy Auch: unit tests \par\bigskip Einzelne Module sollen \IeC {\"U}berpr\IeC {\"u}fungen erm\IeC {\"o}glichen[/latex]

Q: [latex]\centering\sloppy Objektorientierte Modellierung: \par Zustands\IeC {\"u}bergang[/latex]
A: [latex]\centering\sloppy Ver\IeC {\"a}nderung des Objektzustands durch \IeC {\"A}nderung mindestens eines Attributwertes \par\bigskip Ausgangszustand $\longrightarrow$~Folgezustand[/latex]

Q: [latex]\centering\sloppy Objektorientierte Modellierung: \par Zustands\IeC {\"u}bergangsdiagramm eines Objekts[/latex]
A: [latex]\centering\sloppy Veranschaulichung aller Objektzust\IeC {\"a}nde und \IeC {\"U}berg\IeC {\"a}nge: \begin{inlineenumerate} \item Rechtecke mit abgerundeten Ecken (Zust\IeC {\"a}nde) \item Pfeile (\IeC {\"U}berg\IeC {\"a}nge) \item Ausl\IeC {\"o}sende Aktion, optional Bedingung und\slash oder ausgel\IeC {\"o}ste Aktionen (Beschriftung) \item Startzustand: unbeschrifteter Pfeil \item Endzustand: doppelte Berandung \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Objektorientierte Modellierung: \par Zustands\IeC {\"u}bergangstabelle eines Objekts[/latex]
A: [latex]\centering\sloppy Tabellarische Zusammenstellung der m\IeC {\"o}glichen Objektzust\IeC {\"a}nde und ihrer \IeC {\"U}berg\IeC {\"a}nge[/latex]

Q: [latex]\centering\sloppy Endlicher Automat[/latex]
A: [latex]\centering\sloppy Informationsverarbeitendes System, bestehend aus einer endlichen Menge von Zust\IeC {\"a}nden und Zustands\IeC {\"u}berg\IeC {\"a}ngen \par\bigskip Varianten: erkennender und verarbeitender Automat[/latex]

Q: [latex]\centering\sloppy Erkennender Automat[/latex]
A: [latex]\centering\sloppy Endlicher Automat zur Verarbeitung einer Zahlenfolge \par Ausgabe: Wahrheitswert[/latex]

Q: [latex]\centering\sloppy \IeC {\"U}bersetzender Automat[/latex]
A: [latex]\centering\sloppy Endlicher Automat zur Bearbeitung einer Zahlenfolge \par Ausgabe: ver\IeC {\"a}nderte Zahlenfolge[/latex]

Q: [latex]\centering\sloppy Assoziation (zwischen Objekten)[/latex]
A: [latex]\centering\sloppy Auch: Beziehung \par\bigskip Ein Objekt (einer Ausgangsklasse) nutzt die Funktionalit\IeC {\"a}t oder die Daten eines anderen Objektes (einer Zielklasse)[/latex]

Q: [latex]\centering\sloppy Unidirektionale Asssoziation[/latex]
A: [latex]\centering\sloppy Auch: einseitig navigierbare Assoziation \par\bigskip Assoziation, bei der nur ein Objekt die Funktionalit\IeC {\"a}t oder Daten des anderen nutzt[/latex]

Q: [latex]\centering\sloppy Bidirektionale Asssoziation[/latex]
A: [latex]\centering\sloppy Auch: zweiseitig navigierbare Assoziation \par\bigskip Assoziation, bei der beide Objekte die Funktionalit\IeC {\"a}t oder Daten des jeweils anderen nutzten[/latex]

Q: [latex]\centering\sloppy Multiplizit\IeC {\"a}t einer Assoziation[/latex]
A: [latex]\centering\sloppy Auch: Kardinalit\IeC {\"a}t \par\bigskip Anzahl der Objekte einer Klasse, die mit einem Objekt der anderen Klasse in Beziehung stehen \par\bigskip Angabe in der Form $1 : 1$, $1 : n$, $n : 1$ oder $n : m$[/latex]

Q: [latex]\centering\sloppy Darstellung einer Assoziation im Klassendiagramm[/latex]
A: [latex]\centering\sloppy Linie zwischen den Klassenkarten, Benennung und gegebenenfalls Richtungsanzeige, Multiplizit\IeC {\"a}t durch Ziffern bei Ausgangs- und Zielklasse[/latex]

Q: [latex]\centering\sloppy Aggregat[/latex]
A: [latex]\centering\sloppy Klasse mit mindestens einem Attribut, dessen Datentyp durch eine andere (Ziel)Klasse gegeben ist[/latex]

Q: [latex]\centering\sloppy Aggregation[/latex]
A: [latex]\centering\sloppy Spezielle Assoziation, bei der die Ausgangsklasse mindestens ein Attribut besitzt, dessen Datentyp durch die Zielklasse gegeben ist[/latex]

Q: [latex]\centering\sloppy Darstellung einer Aggregation im Klassendiagramm (Erkl\IeC {\"a}rung)[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item Kennzeichnung der Ausgangsklasse durch eine kleine Raute \item Vielfachheit nur auf der Seite der Zielklasse \item Keine Benennung der Assoziation \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Darstellung einer Aggregation im Klassendiagramm[/latex]
A: [latex]\centering\sloppy \begin{center} \footnotesize \begin{pictex}{11mm}{5mm} \ksystem[noxy]{-3}{3}{-1}{1} \pclass[terse]{\textcode{\cclass{Aggregat}}}{}{-2 0} \paggregate[l,xunit=0.5]{-1 0} \pplot{-0.75 0 1 0} \plabel{$n$}{1 0}{-2 -2} \pclass[terse]{\textcode{\cclass{Zielklasse}}}{}{2 0} \end{pictex} \end{center}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Implementierung einer Assoziation[/latex]
A: [latex]\centering\sloppy Deklaration von Attributen in der Ausgangssklasse, deren Datentyp durch die Zielklasse festgelegt ist \par\bigskip Ist die Multiplizit\IeC {\"a}t der Assoziation auf der Seite der Zielklasse~$n > 1$, so ist das Assoziationsattribut ein Feld[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Assoziationsklasse[/latex]
A: [latex]\centering\sloppy Klasse zur Modellierung der Beziehung mit (gegebenenfalls feldwertigen) Attributen, deren Datentyp durch die Ausgangs- und die Zielklasse festgelegt ist[/latex]

Q: [latex]\centering\sloppy Objektidentit\IeC {\"a}t[/latex]
A: [latex]\centering\sloppy Eindeutige Identifizierbarkeit eines Objekts unabh\IeC {\"a}ngig von seinem Objektzustand \par\bigskip \gqq{Zwei Schildkr\IeC {\"o}ten sind verschieden, auch wenn sie gleiche Attributwerte aufweisen}[/latex]

Q: [latex]\centering\sloppy Wertobjekt[/latex]
A: [latex]\centering\sloppy Objekt, dessen Zustand \IeC {\"u}ber die gesamte Lebensdauer unver\IeC {\"a}ndert bleibt \par\bigskip Alle Attribute des Objekts sind als Konstanten deklariert (\textcode{\creserved{final}})[/latex]

Q: [latex]\centering\sloppy Objektorientierte Modellierung: \par Anwendungsfall[/latex]
A: [latex]\centering\sloppy Ablaufanalyse zur zeitlichen Zustands\IeC {\"a}nderung und Abfolge der Methodenaufrufe aller an einer Interaktion beteiligten Objekte \par\bigskip Veranschaulichung durch ein Sequenzdiagramm[/latex]

Q: [latex]\centering\sloppy Interaktion zwischen zwei Objekten[/latex]
A: [latex]\centering\sloppy Senden und Empfangen von Nachrichten durch wechselseitige Methodenaufrufe[/latex]

Q: [latex]\centering\sloppy Senden einer Nachricht von Objekt~\textcode{o1} an Objekt~\textcode{o2}[/latex]
A: [latex]\centering\sloppy Methodenaufruf durch \textcode{o1} \par \textcode{o2.\cmethod{\cvar{Methode}}{}} \par\bigskip \textcode{o1} nutzt die Funktionalit\IeC {\"a}t von \textcode{o2}[/latex]

Q: [latex]\centering\sloppy Empfangen einer Nachricht von Objekt~\textcode{o2} durch Objekt~\textcode{o1}[/latex]
A: [latex]\centering\sloppy Bearbeiten des R\IeC {\"u}ckgabewertes der Methode \textcode{o2.\cmethod{\cvar{Methode}}{}} durch \textcode{o1}[/latex]

Q: [latex]\centering\sloppy Sequenzdiagramm[/latex]
A: [latex]\centering\sloppy UML-Diagramm zur Veranschaulichung von Objektinteraktionen \begin{inlineenumerate} \item Zeitachse vertikal von oben nach unten \item Anordnung der Akteure auf Lebenslinien \item Aktivit\IeC {\"a}tsbalken bei Methodenausf\IeC {\"u}hrung \item Interaktion durch Pfeile \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Oberklasse[/latex]
A: [latex]\centering\sloppy Auch: Eltern-, Basis- oder Superklasse einer Vererbungshierarchie \par\bigskip Klasse~\textcode{K}, die h\IeC {\"o}chstens die Attribute und Methoden einer Unterklasse~\textcode{k} besitzt[/latex]

Q: [latex]\centering\sloppy Elternklasse[/latex]
A: [latex]\centering\sloppy Auch: Ober-, Basis- oder Superklasse einer Vererbungshierarchie \par\bigskip Klasse~\textcode{K}, die h\IeC {\"o}chstens die Attribute und Methoden einer Unterklasse~\textcode{k} besitzt[/latex]

Q: [latex]\centering\sloppy Basisklasse[/latex]
A: [latex]\centering\sloppy Auch: Eltern-, Ober- oder Superklasse einer Vererbungshierarchie \par\bigskip Klasse~\textcode{K}, die h\IeC {\"o}chstens die Attribute und Methoden einer Unterklasse~\textcode{k} besitzt[/latex]

Q: [latex]\centering\sloppy Superklasse[/latex]
A: [latex]\centering\sloppy Auch: Eltern-, Basis- oder Oberklasse einer Vererbungshierarchie \par\bigskip Klasse~\textcode{K}, die h\IeC {\"o}chstens die Attribute und Methoden einer Unterklasse~\textcode{k} besitzt[/latex]

Q: [latex]\centering\sloppy Unterklasse[/latex]
A: [latex]\centering\sloppy Auch: Kindklasse einer Vererbungshierarchie \par\bigskip Klasse~\textcode{k}, die mindestens die Attribute und Methoden einer Oberklasse~\textcode{K} besitzt[/latex]

Q: [latex]\centering\sloppy Kindklasse[/latex]
A: [latex]\centering\sloppy Auch: Unterklasse einer Vererbungshierarchie \par\bigskip Klasse~\textcode{k}, die mindestens die Attribute und Methoden einer Oberklasse~\textcode{K} besitzt[/latex]

Q: [latex]\centering\sloppy Vererbungshierarchie[/latex]
A: [latex]\centering\sloppy Beziehung zwischen Oberklasse~\textcode{K} und Unterklasse~\textcode{k} \par\bigskip \textcode{k} erbt von \textcode{K} \par \textcode{K} vererbt an \textcode{k}[/latex]

Q: [latex]\centering\sloppy Darstellung einer Vererbungsbeziehung im Klassendiagramm[/latex]
A: [latex]\centering\sloppy Kennzeichnen der Oberklasse durch ein unausgef\IeC {\"u}lltes Dreieck \par\bigskip Vererbte Attribute und Methoden nur in der Oberklasse[/latex]

Q: [latex]\centering\sloppy Spezialisierung[/latex]
A: [latex]\centering\sloppy Bilden von Unterklassen einer Klasse[/latex]

Q: [latex]\centering\sloppy Generalisierung[/latex]
A: [latex]\centering\sloppy Zusammenfassen gemeinsamer Attribute und Methoden mehrerer Klassen in einer Oberklasse[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Reserviertes Wort \textcode{\creserved{this}}[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item Aufruf des Konstruktors der selben Klasse innerhalb eines Konstruktors durch \textcode{\cmethod{this}{}} \item Referenz auf das aktuelle Objekt dieser Klasse innerhalb einer Methode durch \textcode{this.\cvar{Element}} \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Reserviertes Wort \textcode{\creserved{super}}[/latex]
A: [latex]\centering\sloppy \begin{inlineenumerate} \item Aufruf des Konstruktors der OberKlasse innerhalb eines Konstruktors durch \textcode{\cmethod{super}{}} \item Referenz auf den Namensraum der Oberklasse durch \textcode{super.\cvar{Element}} \end{inlineenumerate}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par \IeC {\"U}berschreiben einer Methode[/latex]
A: [latex]\centering\sloppy Deklaration einer Methode in einer Unterklasse mit der gleichen Signatur, wie in einer Oberklasse[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Kennzeichnen einer Klasse als Unterklassse[/latex]
A: [latex]\centering\sloppy \begin{minipage}{\linewidth} \ccode \coptional{Modifizierer} \cvar{Unterklasse} \ccr* \creserved{extends} \cvar{Oberklasse} \{ \ccr \ctab \cvar{Code} \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Mehrfachvererbung[/latex]
A: [latex]\centering\sloppy Existenz von zwei oder mehr Oberklassen zu einer Unterklasse \par\bigskip Mehrfachvererbung ist in Java nicht erlaubt![/latex]

Q: [latex]\centering\sloppy Mehrstufige Vererbung[/latex]
A: [latex]\centering\sloppy Bilden von Unterklassen einer Unterklasse (\gqq{Kindes-Kind-Klassen})[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Sichtbarkeit \textcode{\creserved{protected}}[/latex]
A: [latex]\centering\sloppy Auf das entsprechende Element kann nur innerhalb der Klassen des selben Paketes zugegriffen werden \par\bigskip Kennzeichnung im UML-Diagramm durch dem Bezeichner vorangestelltes~\gqq{\textcode{\#}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Standardsichtbarkeit[/latex]
A: [latex]\centering\sloppy Auf das entsprechende Element kann nur innerhalb der Klassen des selben Paketes zugegriffen werden \par\bigskip Kennzeichnung im UML-Diagramm durch dem Bezeichner vorangestelltes~\gqq{\textcode{\textasciitilde}}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Schl\IeC {\"u}sselwort \textcode{\creserved{final}}[/latex]
A: [latex]\centering\sloppy Kennzeichnen eines Elementes als unver\IeC {\"a}nderlich[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration \textcode{\creserved{final} \cvar{Attributbezeichner}}[/latex]
A: [latex]\centering\sloppy Kennzeichnen des Attributs \cvar{Attributbezeichner} als Konstante \par\bigskip Verhindern einer weiteren Wertzuweisung[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration \textcode{\creserved{final} \cvar{Methodenbezeichner}}[/latex]
A: [latex]\centering\sloppy Verhindern des \IeC {\"U}berschreibens der Methode \cvar{Methodenbezeichner} in einer Unterklasse[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration \textcode{\creserved{final} \cvar{Klassenbezeichner}}[/latex]
A: [latex]\centering\sloppy Verhindern des Bildens von Unterklassen der Klasse \cvar{Klassenbezeichner}[/latex]

Q: [latex]\centering\sloppy Abstrakte Klasse[/latex]
A: [latex]\centering\sloppy Klasse, die keine Objekte als Instanzen erlaubt \par\bigskip Gegenteil: konkrete Klasse[/latex]

Q: [latex]\centering\sloppy Konkrete Klasse[/latex]
A: [latex]\centering\sloppy Klasse, die Objekte als Instanzen zul\IeC {\"a}sst \par\bigskip Gegenteil: abstrakte Klasse[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration einer abstrakten Klasse[/latex]
A: [latex]\centering\sloppy \begin{minipage}\linewidth\ccode \coptional{\cvar{Modifizierer}} \creserved{abstract} \ccr* \creserved{class} \cvar{Bezeichner} \{ \ccr \ctab\cvar{Code} \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Abstrakte Methode[/latex]
A: [latex]\centering\sloppy Methode, deren Deklaration nur die Schnittstelle festlegt, ohne einen Methodenrumpf zu implementieren \par\bigskip Gegenteil: konkrete Methode[/latex]

Q: [latex]\centering\sloppy Konkrete Methode[/latex]
A: [latex]\centering\sloppy Methode, die vollst\IeC {\"a}ndig (mit Methodenrumpf) deklariert ist \par\bigskip Gegenteil: abstrakte Methode[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration einer abstrakten Methode[/latex]
A: [latex]\centering\sloppy \begin{minipage}\linewidth\ccode \coptional{\cvar{Modifizierer}} \creserved{abstract} \ccr* \cvar{R\IeC {\"u}ckgabetyp} \cvar{Bezeichner} \ccr* ( \cvar{Parameterliste} ) ; \end{minipage}[/latex]

Q: [latex]\centering\sloppy Partiell abstrakte Klasse[/latex]
A: [latex]\centering\sloppy Abstrakte Klasse, die wenigstens eine konkrete Methode deklariert[/latex]

Q: [latex]\centering\sloppy Darstellung abstrakter Elemente im Klassendiagramm[/latex]
A: [latex]\centering\sloppy Verwenden kursiver Schrift f\IeC {\"u}r den Bezeichner \par\bigskip Alternativ Kennzeichnung durch \gqq{\textcode{\cll abstract\cgg}}[/latex]

Q: [latex]\centering\sloppy Polymorphismus[/latex]
A: [latex]\centering\sloppy Auch: Polymorphie, Vielgestaltigkeit \par\bigskip Verwendung des gleichen Bezeichners f\IeC {\"u}r Objekte unterschiedlicher Klassen (einer Vererbungshierarchie) mit gleicher Schnittstelle[/latex]

Q: [latex]\centering\sloppy Prinzip der Ersetzbarkeit[/latex]
A: [latex]\centering\sloppy Objekte einer Unterklasse m\IeC {\"u}ssen stets eingesetzt werden k\IeC {\"o}nnen, wenn ein Exemplar der Oberklasse gefordert ist[/latex]

Q: [latex]\centering\sloppy Laufzeitpolymorphismus[/latex]
A: [latex]\centering\sloppy Auch: Prinzip der sp\IeC {\"a}ten Bindung \par\bigskip Die Zuordnung eines polymorphen Bezeichners zu einer Klasse (Datentyp!) erfolgt erst zum Zeitpunkt der Programmausf\IeC {\"u}hrung[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Deklaration einer Schnittstelle[/latex]
A: [latex]\centering\sloppy \begin{minipage}\linewidth\ccode \coptional{\cvar{Modifizierer}} \ccr* \creserved{interface} \cvar{Bezeichner} \{ \ccr \ctab\cvar{Code} \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Sprachkonzepte (Java): \par Zuordnung einer Klasse zu einer Schnittstelle[/latex]
A: [latex]\centering\sloppy \begin{minipage}\linewidth \ccode \coptional{\cvar{Modifizierer}} \ccr* \creserved{class} \cvar{Bezeichner} \ccr* \creserved{implements} \cvar{Interfaces} \{ \ccr \ctab\cvar{Code} \ccr \} \end{minipage}[/latex]

Q: [latex]\centering\sloppy Darstellung einer Schnittstelle im Klassendiagramm[/latex]
A: [latex]\centering\sloppy Erg\IeC {\"a}nzen des des Klassenbezeichners durch das Stereotyp \gqq{\textcode{\cll interface\crr}}[/latex]

Q: [latex]\centering\sloppy Kennzeichnen des Erf\IeC {\"u}llens einer Schnittstelle im Klassendiagramm[/latex]
A: [latex]\centering\sloppy Gestrichelte Beziehungslinie mit einem unausgef\IeC {\"u}llten Dreieck auf der Schnittstellenseite[/latex]