\documentclass{bschlangaul-aufgabe}
\bLadePakete{java,uml}
\begin{document}
\bAufgabenMetadaten{
  Titel = {Aufgabe 2},
  Thematik = {Countdown und Observer},
  Referenz = 66116-2018-F.T2-TA2-A2,
  RelativerPfad = Examen/66116/2018/03/Thema-2/Teilaufgabe-2/Aufgabe-2.tex,
  ZitatSchluessel = examen:66116:2018:03,
  BearbeitungsStand = mit Lösung,
  Korrektheit = unbekannt,
  Ueberprueft = {unbekannt},
  Stichwoerter = {Beobachter (Observer), Klassendiagramm, Implementierung in Java},
  EinzelpruefungsNr = 66116,
  Jahr = 2018,
  Monat = 03,
  ThemaNr = 2,
  TeilaufgabeNr = 2,
  AufgabeNr = 2,
}

Es soll eine (kleine) Anwendung entwickelt werden, in der ein Zähler in
1-er Schritten von 5000 bis 0 herunterzählt. Der Zähler soll als Objekt
der Klasse \bJavaCode{Countdown} realisiert werden, die in UML-Notation
dargestellt ist. Das Attribut value soll den aktuellen Zählerstand
speichern, der mit dem Konstruktor zu initialisieren ist. Die Methode
\bJavaCode{getValue} soll den aktuellen Zählerstand liefern und die Methode
\bJavaCode{countdown} soll den Zähler von 5000 bis 0 herunterzählen.
\index{Beobachter (Observer)}
\footcite{examen:66116:2018:03}

Der jeweilige Zählerstand soll von einem Objekt der in untenstehender
Abbildung angegebenen Klasse \bJavaCode{Display} am Bildschirm ausgegeben
werden. Bei der Konstruktion eines \bJavaCode{Display}-Objekts soll es mit
einem \bJavaCode{Countdown}-Objekt verbunden werden, indem dessen Referenz
unter \bJavaCode{myCountdown} abgespeichert wird. Die Methode \bJavaCode{update}
soll den aktuellen Zählerstand vom \bJavaCode{Countdown}-Objekt holen und mit
\bJavaCode{System.out.println} am Bildschirm ausgeben. Dies soll zu Beginn
des Zählprozesses und nach jeder Änderung des Zählerstands erfolgen.

\begin{center}
\begin{tikzpicture}
\umlclass{Display}{}{
  +Display(cd: Countdown)\\
  +update()
}

\umlclass[x=7]{Countdown}{
  -value: Integer
}{
  +Countdown() \\
  +getValue(): Integer\\
  +countdown()
}

\umluniassoc[arg2=-myCountdown,mult2=1,pos2=0.65]{Display}{Countdown}
\end{tikzpicture}
\end{center}

\noindent
Damit das \bJavaCode{Display}-Objekt über Zählerstände des
\bJavaCode{Countdown}-Objekts informiert wird, soll das Observer-Pattern
angewendet werden. Untenstehende Abbildung zeigt die im Observer-Pattern
vorkommenden abstrakten Klassen. (Kursivschreibweise bedeutet abstrakte
Klasse bzw. abstrakte Methode.)

\begin{center}
\begin{tikzpicture}
\umlclass[type=abstract]{Subject}{}{
  +attach(o: Observer)\\
  +notify()
}

\umlclass[x=6,type=abstract]{Observer}{
}{
  +update()
}

\umluniassoc[arg2=-observers,mult2=1,pos2=0.7]{Subject}{Observer}
\end{tikzpicture}
\end{center}

\begin{enumerate}

%%
% a)
%%

\item Welche Wirkung haben die Methoden \bJavaCode{attach} und \bJavaCode{notify}
gemäß der Idee des Observer-Patterns?

\begin{bAntwort}
Das beobachtete Objekt bietet mit der Methode \bJavaCode{attach} einen
Mechanismus, um Beobachter anzumelden und diese über Änderungen zu
informieren.

Mit der Methode \bJavaCode{notify} werden alle Beobachter benachrichtigt,
wenn sich das beobachtete Objekt ändert.
\end{bAntwort}

%%
% b)
%%

\item Welche der beiden Klassen \bJavaCode{Display} und \bJavaCode{Countdown} aus
obenstehender Abbildung spielt die Rolle eines \bJavaCode{Subject} und welche
die Rolle eines \bJavaCode{Observer}?

\begin{bAntwort}
Die Klasse \bJavaCode{Countdown} spielt die Rolle des \bJavaCode{Subject}s, also
des Gegenstands, der beobachtet wird.

Die Klasse \bJavaCode{Display} spielt die Rolle eines \bJavaCode{Observer}, also
die Rolle eines Beobachters.
\end{bAntwort}

%%
% c)
%%

\item Erstellen Sie ein Klassendiagramm\index{Klassendiagramm}, das die
beiden obenstehenden gegebenen Diagramme in geeigneter Weise, \dh
entsprechend der Idee des Observer-Patterns, zusammenfügt. Es reicht die
Klassen und deren Beziehungen anzugeben. Eine nochmalige Nennung der
Attribute und Methoden ist nicht notwendig.

\begin{bAntwort}
\begin{tikzpicture}
\umlclass[type=abstract]{Subject}{}{
  +attach(o: Observer)\\
  +notify()
}
\umlclass[x=6,type=abstract]{Observer}{
}{
  +update()
}
\umluniassoc[arg2=-observers,mult2=1,pos2=0.7]{Subject}{Observer}

\umlclass[y=-3]{Countdown}{
  -value: Integer
}{
  +Countdown() \\
  +getValue(): Integer\\
  +countdown()
}
\umlclass[x=6,y=-3]{Display}{}{
  +Display(cd: Countdown)\\
  +update()
}
\umluniassoc[arg2=-myCountdown,mult2=1,pos2=0.65]{Display}{Countdown}

\umlinherit{Countdown}{Subject}
\umlinherit{Display}{Observer}
\end{tikzpicture}
\end{bAntwort}

%%
% d)
%%

\item Unsere Anwendung soll nun in einer objektorientierten
Programmiersprache Ihrer Wahl (\zB Java oder C++)
implementiert\index{Implementierung in Java} werden. Dabei soll von
folgenden Annahmen ausgegangen werden:

\begin{itemize}
\item Das Programm wird mit einer main-Methode gestartet, die folgenden
Rumpf hat:

\begin{bJavaAngabe}
public static void main(String[] args){
  Countdown cd = new Countdown();
  new Display(cd);
  cd.countdown();
}
\end{bJavaAngabe}

\item Die beiden Klassen Subject und Observer sind bereits gemäß der
Idee des Observer-Patterns implementiert.
\end{itemize}

Geben Sie auf dieser Grundlage eine Implementierung der beiden Klassen
\bJavaCode{Display} und \bJavaCode{Countdown} an, so dass das gewünschte
Verhalten, \dh Anzeige der Zählerstände und Herunterzählen des
Zählers, realisiert wird. Die Methoden der Klassen \bJavaCode{Subject} und
\bJavaCode{Observer} sind dabei auf geeignete Weise zu verwenden bzw. zu
implementieren. Geben Sie die verwendete Programmiersprache an.

\begin{bAntwort}
\def\TmpCode#1{\bJavaExamen{66116}{2018}{03}{#1}}
\TmpCode{Client}
\TmpCode{Subject}
\TmpCode{Observer}
\TmpCode{Countdown}
\TmpCode{Display}
\end{bAntwort}
\end{enumerate}
\end{document}