kart/doc/portfolio.tex

% standard
\documentclass[a4paper,11pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[ngerman]{babel}

\usepackage{titlesec}
\usepackage{tocbibind}
\renewcommand{\listoffigures}{\begingroup
\tocsection
\tocfile{\listfigurename}{lof}
\endgroup}

\setcounter{secnumdepth}{5}
\setcounter{tocdepth}{5}
\titleformat{\paragraph} {\normalfont\normalsize\bfseries}{\theparagraph}{1em}{}
\titlespacing*{\paragraph}
{0pt}{3.25ex plus 1ex minus .2ex}{1.5ex plus .2ex}

%for linkt page numbers in table of content
\usepackage[linktocpage=true]{hyperref}

\usepackage{enumitem}

\hypersetup{%
unicode,pdffitwindow,
pdfkeywords = {pdf, LaTeX, hyperref, thumbnails},
bookmarksopen = true,
bookmarksnumbered = true,
pdfcenterwindow=true,
pdffitwindow = true,
pdfstartview=FitBV,
pdfcreator = {pdflatex},
colorlinks=true, breaklinks=true, %
urlcolor=magenta, % color for \url
filecolor=cyan, % color for file
linkcolor=black, % color for \ref
citecolor=magenta, %color for \cite
menucolor=darkblue,
breaklinks=true,anchorcolor=green
}

% geometry
\usepackage{geometry}
\geometry{ headsep=20pt,
headheight=20pt,
left=21mm,
top=15mm,
right=21mm,
bottom=15mm,
footskip=20pt,
includeheadfoot}

% for using wrapfigures
\usepackage{wrapfig}

% header and footer
\usepackage{datetime}
\newdateformat{dmy}{%
\THEDAY.~\monthname[\THEMONTH] \THEYEAR}
\usepackage{fancyhdr}
\pagestyle{fancy}
\lhead{Noah J. Vogt}
\chead{}
%\rhead{\dmy\today}
\lfoot{}
\cfoot{Gymnasium Kirschgarten, Basel (CH)}
\rfoot{Seite \thepage}
\renewcommand{\footrulewidth}{.4pt}

% fix figure positioning
\usepackage{float}

% larger inner table margin
\renewcommand{\arraystretch}{1.4}

% no paragraph indent
\setlength{\parindent}{0em}

%for spacing
\usepackage{setspace}
%\renewcommand{\baselinestretch}{1.5}
%\onehalfspacing

% graphics package
\usepackage{graphicx}

% use sans serif font
\usepackage{tgheros}
\usepackage{mathptmx}

\usepackage[font={small,it}]{caption}

% for quotes
\newenvironment{nicequote}[2]{
    \begin{center}\begin{quote}\textit{#1}\\\par\raggedleft--- {#2}
    }{
    \end{quote}\end{center}
}


% using \say{} for easier quoting
\usepackage{dirtytalk}

% for code snippits
\usepackage{listings}
\usepackage{color}
\usepackage{xcolor}

\usepackage{minted}
\usemintedstyle{one-dark}

\definecolor{dkgreen}{rgb}{0,0.6,0}
\definecolor{gray}{rgb}{0.5,0.5,0.5}
\definecolor{mauve}{rgb}{0.58,0,0.82}
\definecolor{bg}{HTML}{282C34} % #282C34
\definecolor{shpurple}{HTML}{C301FF} % #C301FF
\definecolor{shgreen}{HTML}{3CFF00} % #3CFF00
\definecolor{shred}{HTML}{EE0606} % #EE0606

%\usepackage[backend=biber,style=apa]{biblatex}
\usepackage[
backend=biber,
style=alphabetic,
sorting=ynt,
]{biblatex}
%\addbibresource{lit/refs.bib}

\usepackage{csquotes}

\begin{document}


\begin{titlepage}

	\centering

    \vspace{5cm}
    \vspace{0.1cm}
	{\huge\bfseries Portfolioarbeit Ergänzungsfach Informatik \par}
	\vspace{0.5cm}
	{\Large eine Arbeit von \par}
	{\Large Noah J. Vogt \par}
    {\Large aus der Klasse 4cg \par}
    \vspace{0.5cm}

    \begin{figure}[H]
        \centering
        \includegraphics[width=.9\textwidth]{media/card-panel.jpg}
    \end{figure}

    \vspace{0.5cm}
    {\Large Fachlehrperson: Victor Yakhontov \par }
    \vspace{0.5cm}
	{\large Geschrieben im Jahr 2022 \par}
    {\large Gymnasium Kirschgarten, Basel-Stadt CH \par}

\end{titlepage}

\tableofcontents
\pagebreak

\section{Einleitung}
\subsection{Darstellung}
Das Produkt dieser Portfolioarbeit ist ein ausführbares Programm mit grafischer Oberfläche, welches ein volles Jass-Kartendeck - also 52 Karten - darstellt und eine Mischfunktion anbietet.\\

\begin{figure}[H]
    \centering
    \includegraphics[width=.7\textwidth]{media/early-screenshot.jpg}
    \caption{Das Produkt}
\end{figure}

Zuerst sind die Karten in sortierter Reihenfolge dargestellt, sie werden erst durch das Drücken auf den \say{Misch}-Knopf gemischt. Dieser Vorgang lässt sich beliebig oft wiederholen durch erneutes Drücken des Knopfes durch den Nutzer. Um wieder zum sortierten Anfangszustand zurück zu gelangen, kann man den \say{Reset}-Button drücken.\\

Da man die Karten alle relativ klein darstellen müsste, um das ganze Kartendeck gleichzeitig zeigen zu können, wurde sich entschieden, die Kartenanzeige in verschiedene Fenster einzuteilen. So gibt es drei Seiten, mit der man durch Anklicken der Arrowbuttons navigieren kann. Jede Seite besteht aus einem Rasterlayout bestehend aus je drei Reihen und sieben Spalten. Die Karten werden von oben links nach unten rechts gefüllt, doch dazu später mehr.\\


\subsection{Abgrenzung}
Es gibt einige Einschränkungen, welche den Rahmen dieser Arbeit setzen:

\begin{itemize}
    \item \textbf{Die Grundbedingungen} Es sollen Abgabetermine und formale Vorgaben erfüllt werden, wie definiert im Arbeitsauftrag.
    \item \textbf{Die Aufgabestellung} Diese gilt zu beachten und soll erfüllt werden mit all ihren Teilaufgaben. Viel weiter darüber hinaus soll die App funktionstechnisch also nicht gehen, stattdessen soll vor dem Hinzufügen neuer Features sorgfältig abgewogen werden, ob diese zu weit gehen oder noch im Sinne der Aufgabenstellung zu verstehen sind und somit noch im Rahmen sind.
    \item \textbf{Die Programmiersprache} Zur Lösung der Aufgabestellung und Programmierung der App soll die altbekannte, oft geliebte und gehasste Programmiersprache \texttt{Java} verwendet werden. Davon ausgenommen ist hier aber das Buildscript (\texttt{build.sh}), welches das Programm kompiliert und eine \texttt{.jar}-Executable ausgibt.
\end{itemize}

\subsection{Vorausschau}

Im darauffolgenden Hauptteil dieser Portfolioarbeit wird zuerst genauer auf die Aufgabestellung eingegangen, diese analysiert und interpretiert. Dies ist ein wichtiger Schritt, denn er soll den weiteren Ablauf des Projekts bestimmen.\\

Als nächstes wird der grobe Lösungsansatz vorgestellt, und immer weiter vertieft. Dazu wird sich unter anderem auch reichlich bedient an Codebeispielen, Konzepten, Skizzen, Diagrammen und Screenshots, um durch die grafische Darstellung die Konzepte besser anschaulich zu machen.\\

Abschliessend erfolgt der Rückblick auf das Projekt und der Autor bewertet die Erfahrungen, das Gelernte und die Resultate.


\section{Hauptteil}

\subsection{Aufgabestellung und Interpretation}

\textit{\textbf{1a)} Implementieren Sie zunächst eine ausführbare (d.h. mit einer main()–Methode) Klasse Karten, welche die Karten des Kartenspiels erzeugen und grafisch (s. Abb. 1) auslegen kann.}

\begin{figure}[H]
    \centering
    \includegraphics[width=.45\textwidth]{media/spielkarten.jpg}
    \caption{Spielkarten}
\end{figure}

Hier im Beispielbild wurde die Auslegung der Karten übereinanderliegend dargestellt, doch es wurde sich für eine nicht überlappende Darstellung der Karten entschieden, das die besser zu einem grafischen Programm passe aufgrund erhöhter Lesbarkeit und wesentlich geringerem Arbeitsaufwand.\\

Es ist nicht klar gegeben, ob die ausführbare Klasse \texttt{Karten} mit \texttt{main()}-Methode als einzelnes Source File dastehen soll oder ob darin verwendete Module auch in anderen Source Files gespeichert werden können. Es wurde sich für diese Arbeit entschieden, das letztere zu wählen, um einen besser strukturierten Gesamtquellcode zu erreichen.\\

\textit{\textbf{1b)} Für das Kartenspiel benötigen Sie auch eine Mischmaschine, welche die Karten mischen kann. Objekte der entsprechenden Klasse MischMaschine müssen in der Lage sein:
\begin{enumerate}[label=\roman*.]
    \item Karten aufzunehmen,
    \item die enthaltenen Karten zu mischen,
    \item alle enthaltenen Karten zu durchlaufen.
\end{enumerate}
Sie lernen die Klasse \texttt{java.util.ArrayList} kennen und stellen dadurch fest, dass diese bereits die
Anforderungen (i) und (iii) über die beiden Methoden \texttt{add()} und \texttt{Iterator()} erfüllt. Für die Realisierung der Klasse \texttt{MischMaschine} können Sie also grundsätzlich die Klasse \texttt{ArrayList} und das Konzept der Vererbung nutzen. Um die Anforderung (ii) zu implementieren, müssen Sie zusätzlich Ihre eigene Methode \texttt{mischen()} schreiben (s. die Methode \texttt{java.util.Collections.shuffle()} aus der Klasse \texttt{java.util.*}), die das Mischen tatsächlich realisiert, und zu Ihrer Klasse hinzufügen.
Implementieren Sie auf dieser Weise die externe Klasse MischMaschine, die Objekte der Hauptklasse \texttt{Karten} aufnehmen, mischen und durchlaufen kann.}\\

Dass Objekte der Klasse \texttt{MischMaschine} in der Lage sein sollen (i) - (iii) zu erfüllen ist verständlich, doch da jedoch die Klasse eine grafische Oberfläche starten soll, wird es als sinnvoller empfunden diese drei Punkte durch die Klasse resp. Datentyp-Klasse \texttt{KartenDeck} - welche wiederum Daten der Datentyp-Klasse \texttt{Karte} bearbeitet - zu realisieren. Dies wird hier nicht als Widerspruch zur Aufgabenstellung, sondern lediglich als Interpretation verstanden.\\

\textit{\textbf{1c)}: Ändern Sie die Hauptklasse Karten so ab, dass sie alle erzeugten Karten des Kartenspiels an die Klasse MischMaschine übergibt. Die MischMaschine soll die Karten mischen und
anschliessend sie an die Hauptklasse Karten in der gemischten Reihenfolge zurückgeben, wo sie schlussendlich auf den Bildschirm im grafischen Interface ausgelegt werden.}\\

Hier macht es relativ wenig Sinn nach Ansicht des Autors dieser Arbeit, die Hauptklasse \texttt{Karten} direkt zu bearbeiten, um die im grafischen Interface abgebildeten Karten zu mischen. Denn solch eine Änderung sollte in der jeweiligen aus der Klasse \texttt{Karten} gecallten Klasse geschehen, im Falle der hier präsentierten Lösung ist das in der Klasse \texttt{MainWindow}.\\

Auch dass die zur Mischung stehenden Karten an die Klasse \texttt{MischMaschine} abgegeben werden soll, erscheint auch nicht direkt sinnvoll. In dieser Lösung wird das Kartendeck im User Interface in einer Instanz der Klasse \texttt{KartenDeck} gespeichert und die Mischfunktion als Methode dieser Klasseninstanz einfach gecallt.



\subsubsection{Bewertung}
Vom Autor dieser Arbeit wird diese Aufgabe als doch recht sinnvoll angesehen. Einerseits ist das Handling eines Kartenspiels resp. eines Kartendecks ein recht passender Fall, wo man die Prinzipien der OOP-Konzepts (Objekt-Orientierten Programmierung) anwenden kann: So erschien es sinnvoll eine Klasse \texttt{Karte} zu schreiben um den Datentyp einer Karte als Objekt darzustellen inklusive Getter- und Settermethoden und passenden Attributen. Ein Kartendeck wäre dann eine Klasse welche eine \texttt{ArrayList} ist, welche Objekte der Klasse \texttt{Karte} aufnehmen, und passende Methoden zu deren Manipulation bieten (Karten hinzufügen, entfernen, mischen, etc.). Ein paar OOP-Konzepte wurden im Laufe des Unterrichts im Ergänzungsfach Informatik schon angeschnitten, weshalb es nach der Meinung des Autors auch schön ist, diese wiederverwenden zu können. \\

Was auch im Unterricht behandelt wurde, sind simple grafische Interfaces mit der Flanagan-Bibliothek und der der \texttt{javax.swing}-Bibliothek. Nach der Erinnerung des Autors geschah dies in der Form von In- und Output Popup-Fenstern und Filepickern. Diese und die Swing-Bibliothek konnten auch wieder verwendet werden für die Erstellung der grafischen Oberfläche des Programmes.\\

Auf die Schlussfolgerungen und Reflexionen auf die Arbeit als gesamtes wird noch später im letzten Punkt genauer eingegangen, doch die Arbeit erschien dem Autor ausgewogen bezüglich Machbarkeit, Aufwand, Themenbereichen (Karten Backend und GUI Frontend).

\subsection{Lösungsansatz}

\subsubsection{Übersicht}

Zuerst hier eine kleine grafische Übersicht der verwendeten Klassen, ihrer kurzen Erklärung:

\begin{figure}[H]
    \centering
    \includegraphics[width=\textwidth]{media/class-overview.png}
    \caption{Grobe Übersicht}
\end{figure}

Wie in der obigen Abbildung ersichtlich, wird als erstes die Hauptklasse \texttt{Karten} durch das \texttt{SwingUtilities.
invokeLater()}-Environment ausgeführt, welches den einzigen Nutzen hat, das Grafikfenster zu starten, welches in der Klasse \texttt{MainWindow} geschrieben ist.\\

Das Grafikfenster besteht aus verschiedenen Komponenten der AWT- und Swing-Library, doch darauf wird später im Text noch genauer eingegangen. Grob ist das Programm aber eingeteilt in ein Top-Panel, Bottom-Panel und eine Kartenansicht dazwischen.\\

Um mit dem Kartendeck im Grafikfenster sinnvoll umgehen zu können, wurde ein Objekt resp. eine Klasse names \texttt{KartenDeck} erstellt, welche alle nötigen Methoden besitzt für die Manipulation seines Attributs, einer \texttt{ArrayList} des Typs \texttt{Karte}.

\subsubsection{Grafisches Interface}

Um ein Kartenspiel grafisch darzustellen wurde überlegt, es müsse ein Fenster her, das in der Lage ist alle 52 Karten des Decks darzustellen. Und das wie schon bei der Aufgabeninterpretation erwähnt, am besten ohne Überlappungen von Karten. Die hier sichtbare, ursprüngliche Bleistift-Skizze wurde fast eins zu eins umgesetzt und kaum umkonzipiert:

\begin{figure}[H]
    \centering
    \includegraphics[width=.6\textwidth]{media/skizze.png}
    \caption{ursprüngliches Konzept}
\end{figure}

Um dieses Konzept umsetzen zu können, wurden verschiedene JComponents der SWING-Library eingesetzt welche folgendermassen organisiert sind in der Klasse \texttt{MainWindow}:

\begin{figure}[H]
    \centering
    \includegraphics[width=.7\textwidth]{media/gui-overview.png}
    \caption{GUI Komponenten}
\end{figure}

\subsubsection{Datenklasse \texttt{Karte}}
Um eine Sache in ein Datenobjekt zu übersetzen, muss man sich erst einmal überlegen, was für Eigenschaften eine Spielkarte so besitzt. Da wären zuerst die \textit{Kartenwerte} von \say{2} bis \say{Ass} und die sogenannten \textit{Kartenfarben} Pik, Karo, Herz und Kreuz. Mit diesen beiden Eigenschaften kann eine Karte \textit{eindeutig} definiert werden. Diese beiden Karteneigenschaften sollen dann dementsprechend Attribute der Klasse \texttt{Karte} sein.\\

Da die Kartenfarbe nur vier feste, gleichwertige Werte annehmen kann, welche sich am besten durch ihren Namen referenzieren lassen, scheint hier die Nutzung eines \texttt{enum}s angebracht.\\

Die Kartenwerte bestehen ja aus \say{2}, \say{3}, \say{4}, \say{5}, \say{6}, \say{7}, \say{8}, \say{9}, \say{10}, \say{Bauer}, \say{Dame}, \say{König}, \say{Ass}. Diese sind im Gegensatz zu den Karten nicht gleichwertig und lassen sich ganzzahligen Werten zuordnen. Für dieses Projekt sind diese wie folgt definiert:

\begin{table}[H]
\centering
\begin{tabular}{|c|c|}
    \hline
    \textbf{Kartenwert} & \textbf{Integer Wert}\\
    \hline
    \say{1} & \texttt{1}\\
    \hline
    \say{2} & \texttt{2}\\
    \hline
    \say{3} & \texttt{3}\\
    \hline
    \say{4} & \texttt{4}\\
    \hline
    \say{5} & \texttt{5}\\
    \hline
    \say{6} & \texttt{6}\\
    \hline
    \say{7} & \texttt{7}\\
    \hline
\end{tabular}
    \hspace{1cm}
\begin{tabular}{|c|c|}
    \hline
    \textbf{Kartenwert} & \textbf{Integer Wert}\\
    \hline
    \say{8} & \texttt{8}\\
    \hline
    \say{9} & \texttt{9}\\
    \hline
    \say{10} & \texttt{10}\\
    \hline
    \say{Bauer} & \texttt{11}\\
    \hline
    \say{Dame} & \texttt{12}\\
    \hline
    \say{König} & \texttt{13}\\
    \hline
    \say{Ass} & \texttt{14}\\
    \hline
\end{tabular}
\end{table}

Im Code wurden die Attribute der Klasse \texttt{Karte} wie folgt umgesetzt:

\begin{listing}[H]
\begin{minted}[bgcolor=bg]{java}
public class Karte {
    public enum Farbe {
        KREUZ, PIK, KARO, HERZ;
    }

    private static final int MIN_WERT = 2;
    private static final int MAX_WERT = 14;

    private int wert;
    private Farbe farbe;
\end{minted}
\caption{Deklaration der Klasse \texttt{Karte} und deren Attributen}
\label{lst:karte}
\end{listing}


\subsubsection{Datenklasse \texttt{KartenDeck}}

Der Sinn dieser Klasse ist die Speicherung, Verwaltung und sonstige Manipulation seines einzigen Attributs, einer \texttt{ArrayList} bestehend aus Typen der Klasse \texttt{Karte}.

\begin{listing}[H]
    \begin{minted}[bgcolor=bg]{java}
    public class KartenDeck {
        protected ArrayList<Karte> kartenListe = new ArrayList<Karte>();
    \end{minted}
    \caption{Deklaration der Klasse \texttt{KartenDeck} und seinem Attribut}
\end{listing}

Für die Verwaltung dieses Kartendecks bietet die Klasse einige nützliche, öffentliche Methoden wie zum anhängen und Löschen von Karten (\texttt{appendKarte(Karte karte)} und \texttt{removeKarte(Karte karte)}), dem generieren eines neuen Decks (\texttt{generateFullDeck()}), dem geordneten ausgeben aus der Kommandozeile (\texttt{print()}) und der Mischfunktion (\texttt{mischen()}). Auch zu erwähnen sind die Getter- und Settermethoden (\texttt{getDeck}, \texttt{getDeckSize()}, \texttt{setDeck()}).


\subsection{Vorstellung und Erklärung}
\subsubsection{Top Panel}
\begin{figure}[H]
    \centering
    \includegraphics[width=.9\textwidth]{media/top-panel.jpg}
    \caption{Screenshot: Bottom Panel}
\end{figure}

Das Panel besteht aus einem \texttt{JComponent} des Typs \texttt{JPanel}. Beginnend von links nach rechts sieht man zuerst ein \texttt{JLabel} mit dem Titel der App, \say{Mischmaschine}. Zum JLabel wurde auch noch ein Shuffle-Logo angefügt, passend zur Funktion des Programmes - dem zufälligen Mischen.\\

Als nächstes kommt der Misch-Button. Dieser sorgt dafür dass alle Karten - auch die welche sich auf einer anderen Seite befinden und somit nicht zu sehen sind - gemischt werden in dem die Funktion \texttt{KartenDeck.\\mischen()} aufgerufen wird. Dann wird der das Karten-Panel geupdated damit die Änderungen der Kartenreihenfolge sichtbar werden für den Nutzer.\\

Der Reset-Button versetzt die App wieder in ihren Anfangszustand: Ein vollständiges, sortiertes Kartendeck wird angezeigt. Dazu wird das Kartendeck neu generiert mit der \texttt{KartenDeck.generateFullDeck()}-Methode, und schliesslich das Kartenpanel geupdated.

\subsubsection{Bottom Panel}
\begin{figure}[H]
    \centering
    \includegraphics[width=.9\textwidth]{media/bottom-panel.jpg}
    \caption{Screenshot: Bottom Panel}
\end{figure}

Das Bottom-Panel hat links und rechts zwei Arrow-Buttons - des Typs \texttt{JButton} - mit der man zwischen den verschiedenen Seiten des Kartenpanels wechseln kann. Doch bevor diese gewechselt werden, wird geprüft ob es überhaupt nötig ist: Denn wenn man schon auf Seite 3 von 3 ist und auch den Pfeil nach rechts klickt, macht es ja keinen Sinn zu berechnen was auf Seite 4 ist und auf diese nicht-existente Seite zu wechseln.\\

Zwischen diesen beiden Knöpfen sind noch zwei \texttt{JLabel} welche die insgesamte Anzahl der Karten anzeigt und die aktuelle resp. letztmögliche Seitenanzahl der Kartenanzeige.

\subsubsection{Card Panel}
\begin{figure}[H]
    \centering
    \includegraphics[width=.9\textwidth]{media/card-panel.jpg}
    \caption{Screenshot: Card Panel}
\end{figure}

Das Card Panel ist für den Endnutzer eigentlich nichts mehr als ein Rasterlayout, in dem die Karten der aktuelle Seite angezeigt werden. Die Sortierung verfolgt immer diesem Schema: Zuerst wird die oberste Reihe von links nach rechts durchgegangen, dann wird eine Reihe runtergegangen und auch hier wird wieder von der linkesten bis zur rechtesten Spalte durchiteriert, und dass bis zur jeweils letzen Reihe der jeweiligen Seite. Wenn eine Seite weniger Karten als ihre maximal mögliche Kapazität anzeigen soll, wird der Rest des Platzes durch unsichtbare Platzhalter-Karten gefüllt.

\subsubsection{Farbschema}

Damit die Farben des User Interfaces einigermassen zusammenpassen vom Kontrast der Farbstärke usw. Anstatt einfach den Default-Look der verschiedenen \texttt{JComponent}s zu übernehmen, wurde sich entschieden ein recht bekanntes, beliebtes und etabliertes Farbschema zu nehmen namens \say{Nord}. Dieses wird oft verwendet um den Style seiner verschiedenen Desktopprogramme zu vereinheitlichen, oder um in seinem Terminalemulator und seinem Texteditor die gleichen Farben zu haben.\\

So wurde den Knöpfen, Tool-Tips, Labels und Panel-Hintergründen eine der Farben aus dem Nord-Theme gegeben. Das einzige was nicht explizit an das Farbschema angepasst wurde, sind die Spielkarten. Diese passen nach der Meinung des Autors aber gut zum Rest des Programmes mit Nord-Theme. Mehr Informationen zu diesem Colorsheme sind erfassbar unter diesem Link: \url{https://www.nordtheme.com/}.

\subsection{Abschluss / Rückblick}

Dem Autor hat das Programmieren der App doch recht Spass gemacht. Er konnte eine neue GUI-Library kennenlernen, und sich in etwa drei bis vier Stunden in diese einarbeiten. Auch die Erstellung der Datenklasse empfand dieser als interessant.\\

% cite uncle bob
Es wurde versucht die Konzepte der OOP so gut wie möglich umzusetzen und sich an den Tipps und Tricks aus dem Buch \say{Clean Code} von Robert C. Martin zu orientieren und diese umzusetzen. Bekannt geworden ist Martin unter dem Spitznamen \say{Uncle Bob} für seine spannenden Präsentationen und seine \say{SOLID Principles} (Single Responsibility, Open/Closed Principle, Liskov Substitution, Dependency Inversion). SOLID wurde auch versucht zu befolgen, mit einer Ausnahme: Dependency Inversion. Denn dazu hätten noch viel mehr abstrakte Klassen resp. Interfaces erstellt werden müssen, z.B. hätte man anstatt die Jasskarten direkt in der Klasse \texttt{Karten} direkt zu implementieren daraus eine abstrakte Klasse machen müssen und eine Subclass für Jasskarten erstellen müssen mit einem Namen wie \texttt{JassKarten}.\\

Mit dem Produkt - der MischMaschine mit .-jar-Executable - ist der Autor auch sehr zufrieden. Es kam ein wirklich sehr portables, intuitives und für ein JVM-Bytecode-Programm performantes Produkt mit einem grafisch ansprechenden Interface heraus. Natürlich hat das Programm in dieser Form keinen \say{Real-World-Use-Case}, aber man kann ja auch immer nicht alles haben.\\

Man stellt sich natürlich auch die Frage, wie man das Programm erweitern könnte. Was naheliegend in den Sinn käme, wäre eine eine Möglichkeit Karten auszuwählen, um diese löschen zu können und ein Button, mit der man neue Karten der Kartenanzeige hinzufügen könnte. Ferner wäre es sinnvoll, das Programm so auszubauen, dass statt einer reinen mischbaren Kartenanzeige auch die Möglichkeit besteht, typische Kartenspiele wie z.B. Blackjack zu realisieren. Auch wäre es noch gut, selber andere Kartenformen als nur Jasskarten verwenden zu können, so beispielsweise Uno-Karten.\\

Wie es auch sonst bei einigen Software-Projekten des Autors dieser Arbeit der Fall ist, ist auch dieses Programm online verfügbar auf GitHub. Der Source Code für die App und dieser Text sind einsehbar unter \url{https://github.com/noahvogt/kart/}.

\end{document}