Fachhochschule Dortmund

Programmierung II

Projektabschlussbericht
Daily Tracker

Mónica Sofía Grijalva de León

Matrikelnummer: 7211948
23. Juni 2023
 Inhaltsverzeichnis

1 Kurzzusammenfassung .................................................................................................. 3
2 Verwendete Technologien ............................................................................................. 4
3 Lösungsstrategie ............................................................................................................. 5
3.1 Daten und Logik (Model) ......................................................................................... 5
3.2 Controller .................................................................................................................... 7
3.3 Graphische Darstellung (View) ............................................................................... 9
3.4 ObservableList......................................................................................................... 11
4 Algorithmus ..................................................................................................................... 13
4.1 UML-Diagramm ....................................................................................................... 13
4.2 AddTask ................................................................................................................... 14
4.3 Drag and Drop ......................................................................................................... 15
4.4 Timestamp ............................................................................................................... 15
4.5 Retrieve Items ......................................................................................................... 16
4.6 Import ........................................................................................................................ 16
4.7 Future Work ............................................................................................................. 17
5 Referenzen ..................................................................................................................... 19
6 Anhang A – Quellcode .................................................................................................. 20
6.1 Modell – Quellcode ................................................................................................. 20
6.2 Controller – Quellcode ........................................................................................... 25
6.3 View – Quellcode .................................................................................................... 27
6.4 Main – Quellcode .................................................................................................... 32

Projektabschlussbericht 2 Praktikum PR2, SS 2023

1 Kurzzusammenfassung
Das Hauptziel des Projekts ist die Implementierung eines MVC-Java-Projekts (Model-View-
Controller), einer Softwarearchitektur, die eine Anwendung in separate Komponenten aufteilt:
das Modell (das Daten und Logik umfasst), die Ansicht (die die Benutzeroberfläche darstellt)
und den Controller (der Benutzereingaben verarbeitet und das Modell/die Ansicht
entsprechend aktualisiert). (Vats, 2020)

Dieses Projekt bietet den Nutzern eine Softwarelösung zur effektiven Verwaltung ihrer
täglichen Aufgaben. Durch den Einsatz dieses Softwareprodukts sind die Benutzer in der
Lage, ihre Aufgaben zu verfolgen, ihren Fortschritt zu überwachen und die allgemeine
Produktivität zu steigern. Die Aufgabenverfolgung bietet zahlreiche Vorteile, u.a. die
Kultivierung dauerhafter, guter Gewohnheiten. Sie ermöglicht es dem Einzelnen, sich einen
umfassenden Überblick über die täglichen Leistungen zu verschaffen und Bereiche mit
Verbesserungsbedarf zu identifizieren.

Darüber hinaus bietet diese Software die Möglichkeit, die verfolgten Aufgaben als
Textdateien zu importieren und auf den persönlichen Geräten der Benutzer zu speichern.
Durch das Speichern des Tagesfortschritts kann der Benutzer ihre Leistung konsequent
verfolgen und ihre Ziele über einen längeren Zeitraum verfolgen.

Projektabschlussbericht 3 Praktikum PR2, SS 2023

2 Verwendete Technologien

Das Programm wurde mit IntelliJ IDEA Version 2022.1.2 als integrierte
Entwicklungsumgebung (IDE) entwickelt. Das Projekt nutzt das Azul Zulu SDK Version
17.0.6, das wesentliche Klassen aus verschiedenen Paketen bietet, die für die
Implementierung erforderlich sind. Insbesondere wurden die folgenden Pakete verwendet:
javafx.collections, javafx.scene.control, javafx.scene.input (mit besonderem Schwerpunkt auf
den Klassen ClipboardContent und Dragboard), java.io und java.time. (Azul, 2021)

Diese Pakete stellen wichtige Funktionalitäten für das Programm bereit. Das Paket
javafx.collections bietet Klassen und Schnittstellen für den Umgang mit Sammlungen von
JavaFX-Eigenschaften und ermöglicht so eine effiziente Datenverwaltung. Das Paket
javafx.scene.control bietet eine Vielzahl von Steuerelementen für die Benutzeroberfläche,
wie z. B. Schaltflächen und Beschriftungen, die die Erstellung einer interaktiven Oberfläche
erleichtern. Das javafx.scene.input-Paket, insbesondere die Klassen ClipboardContent und
Dragboard, ermöglicht die Unterstützung von Clipboard-Operationen und Drag-and-Drop-
Funktionen innerhalb der Anwendung. Das java.io-Paket bietet Klassen für Eingabe-
/Ausgabeoperationen und ermöglicht die Handhabung von Dateien und die Datenpersistenz.
Das java.time-Paket schließlich bietet Klassen für die Verwaltung von Datum und Uhrzeit, die
bei zeitbasierten Operationen und der Zeitplanung helfen. (Oracle, kein Datum)

Darüber hinaus erwies sich der in IntelliJ IDEA eingebaute Scene Builder als wertvolles
Werkzeug, das einen umfassenden Satz von Elementen und Komponenten bietet, die für
den Aufbau der Benutzeroberfläche des Programms erforderlich sind.

Projektabschlussbericht 4 Praktikum PR2, SS 2023

3 Lösungsstrategie
3.1 Daten und Logik (Model)

Der ursprüngliche Prototyp wurde ohne Modell erstellt, so dass alle Programmfunktionen
direkt in der Steuerung implementiert wurden. Bei diesem Ansatz fehlte die Datenlogik und
die Interaktion mit Datenquellen war nicht möglich. Durch die direkte Eingabe von
Funktionen in die Steuerung ergaben sich Nachteile wie eine unzureichende Trennung von
Belangen, Code-Redundanz und begrenzte Datenverwaltungsmöglichkeiten. Eine spezielle
Modellkomponente ist unerlässlich, um die Codeorganisation zu verbessern, eine effiziente
Datenverarbeitung zu ermöglichen und die Skalierbarkeit und Wartbarkeit zu fördern.

Die Modellklasse im aktuellen Projekt umfasst eine Reihe von Methoden zur effektiven
Datenverwaltung.

Die Methode `addTask(String text)` spielt eine entscheidende Rolle, indem sie das
Hinzufügen neuer Aufgaben zu `listView1` ermöglicht. Durch die Verwendung der
Datenstruktur `ObservableList` stellt das Modell sicher, dass alle an der Liste
vorgenommenen Änderungen automatisch in die Ansicht übernommen werden. Diese
nahtlose Synchronisierung zwischen dem Modell und der Benutzeroberfläche ermöglicht
eine effiziente Datenverwaltung.

Die Methode `Drag(ListView<String> listView1, ListView<String> listView2, ListView<String>

listView3)` erweitert die Möglichkeiten der Datenmanipulation, indem sie Drag-and-Drop-
Funktionalität zwischen den angegebenen Listenansichten ermöglicht. Durch die Nutzung
der JavaFX-API für Drag-and-Drop verwaltet das Modell effektiv die Bewegung von
Elementen zwischen `listView1`, `listView2` und `listView3`. Diese Funktion bietet den
Benutzern eine benutzerfreundliche Möglichkeit, Daten innerhalb der Anwendung neu
anzuordnen und zu übertragen.

Um den Zeitpunkt von Aufgaben genau zu erfassen, ruft die Methode `getCurrentTime()` das
aktuelle Datum und die Uhrzeit im angegebenen Format ab. Diese Informationen werden in
erster Linie verwendet, um Zeitstempel an die zu `listView3` hinzugefügten Elemente
anzuhängen. Durch die effektive Verwaltung zeitbezogener Daten gewährleistet das Modell
eine genaue Verfolgung und Analyse der Aufgabenerledigung.

Projektabschlussbericht 5 Praktikum PR2, SS 2023

Die Methode `retrieveItems()` konsolidiert die Daten von `listView2` und `listView3`. Durch
die Kombination der relevanten Elemente und das Hinzufügen zu `listView4` verwaltet das
Modell effektiv die Verarbeitung und Umwandlung von Daten. Diese Konsolidierung bietet
einen umfassenden Überblick über die Aufgaben und die damit verbundenen Details und
verbessert die Kohärenz und Zugänglichkeit der Daten.

Durch die Methode `exportToTxtFile(String filePath)` ist den Export des Inhalts von
`listView4` in eine durch den Parameter `filePath` angegebene Textdatei möglich. Durch den
Einsatz von `BufferedWriter` und `FileWriter` verwaltet das Modell effektiv den Prozess des
Schreibens der Daten in die Datei. Diese Funktionalität fördert die Datenpersistenz und
ermöglicht es den Benutzern, ihre verfolgten Aufgaben außerhalb der Anwendung zu
speichern und darauf zuzugreifen.

Um das Löschen von Daten zu erleichtern, löscht die Methode `deleteAll()` den Inhalt von
`listView1`, `listView2` und `listView3`. Diese Funktionalität bietet eine einfache Möglichkeit,
die Listen zurückzusetzen und alle gespeicherten Aufgaben zu entfernen. Durch die effektive
Verwaltung der Datenlöschung gewährleistet das Modell die Konsistenz und bereitet die
Listen auf neue Dateneinträge vor.

Die Methode `close()` steht zwar nicht in direktem Zusammenhang mit der Datenverwaltung,
sorgt aber für die ordnungsgemäße Beendigung des Programms. Indem sie alle nicht
gespeicherten Daten oder Ressourcen vor dem Schließen der Anwendung behandelt, fördert
diese Methode die Datenintegrität und die ordnungsgemäße Beendigung des Programms.

Zusammenfassend lässt sich sagen, dass jede Methode der Modellklasse zu einer
effizienten Datenverwaltung innerhalb des Projekts beiträgt. Sie erleichtern das Hinzufügen,
Löschen, Manipulieren, Konsolidieren und Persistieren von Daten und stellen sicher, dass
das Modell verschiedene Aspekte der Datenverarbeitung und -interaktion in der gesamten
Anwendung effektiv handhabt.

Projektabschlussbericht 6 Praktikum PR2, SS 2023

3.2 Controller

Der Controller spielt eine wichtige Rolle bei der Erleichterung der Kommunikation zwischen
dem Modell (das die Daten und die Geschäftslogik darstellt) und dem View (der die
Benutzeroberfläche darstellt). Seine Hauptaufgabe besteht darin, Benutzereingaben aus der
Ansicht zu verarbeiten, das Modell entsprechend zu aktualisieren und sicherzustellen, dass
alle Änderungen in der Ansicht wiedergegeben werden.

In der Methode `initialize()` legt der Controller die anfängliche Einrichtung fest. Er instanziiert
eine neue Instanz der Klasse `Model` und assoziiert die entsprechenden `ObservableList`-
Instanzen aus dem Model mit den entsprechenden `ListView`-Instanzen im View. Zusätzlich
aktiviert es die Drag-and-Drop-Funktionalität, indem es die Methode `Drag()` von der Klasse
`Model` aufruft und die notwendigen `ListView`-Instanzen übergibt.

Die Methode `addTask()` wird ausgelöst, wenn der Benutzer beabsichtigt, eine neue
Aufgabe hinzuzufügen. Sie ruft den in das Eingabefeld `textField1` in der Ansicht
eingegebenen Text ab, nimmt die Aufgabe mit der Methode `addTask()` in das Modell auf
und löscht das Eingabefeld für zukünftige Eingaben.

Wenn der Benutzer die Methode `retrieveItems()` aufruft, werden Elemente aus dem Modell
abgerufen und im `listView4` in der Ansicht angezeigt. Durch den Aufruf der Methode
`retrieveItems()` aus der Klasse `Model` wird die entsprechende Datenverarbeitung
eingeleitet. Anschließend wird die aktualisierte `ObservableList` aus dem Modell der
`listView4` zugewiesen, um sicherzustellen, dass die neuesten Elemente in der Ansicht
wiedergegeben werden.

Die Methode `exportToTxtFile()` dient dem Zweck, den Inhalt von `listView4` in eine
Textdatei zu exportieren. Sie verwendet den JavaFX `FileChooser`, um dem Benutzer die
Auswahl einer Zieldatei zu ermöglichen. Sobald eine Datei ausgewählt wurde, wird die
Methode `exportToTxtFile()` aus der Klasse `Model` aufgerufen, um den Exportprozess zu
verarbeiten und die Daten in der angegebenen Datei zu speichern.

Die Methode `deleteAll()` ist mit der Aktion "Delete All" innerhalb der Benutzeroberfläche
verbunden. Wenn sie ausgelöst wird, verwendet sie die Methode `deleteAll()` aus der Klasse
`Model`, um alle Aufgaben und zugehörigen Daten innerhalb des Modells zu löschen und
den Zustand der Anwendung effektiv zurückzusetzen.

Projektabschlussbericht 7 Praktikum PR2, SS 2023

Um ein geordnetes Beenden der Anwendung zu ermöglichen, ist die Methode `close()` mit
der Aktion "Close" verknüpft. Durch den Aufruf der Methode `close()` aus der Klasse `Model`
werden alle notwendigen Aufräum- oder Beendigungsschritte durchgeführt, bevor das
Programm sicher beendet wird.

Insgesamt fungiert diese Controller-Klasse als Vermittler zwischen Benutzerinteraktionen,

Datenmanipulationen und Aktualisierungen der Ansicht. Sie sorgt für eine nahtlose
Kommunikation zwischen der Benutzeroberfläche und dem zugrundeliegenden Datenmodell
und ermöglicht so eine kohärente und interaktive Benutzererfahrung.

Projektabschlussbericht 8 Praktikum PR2, SS 2023

3.3 Graphische Darstellung (View)

Im Laufe der verschiedenen Prototypen wurden erhebliche Änderungen an der grafischen

Darstellung der Ansicht vorgenommen. Ursprünglich wurde ein Raster (GridPane)
verwendet, um die Elemente so anzuordnen, wie es in Abbildung 1 dargestellt ist. Die
Anordnung der Elemente auf der Grundlage der Rasterparameter entsprach jedoch nicht den
gewünschten grafischen Gestaltungszielen. Obwohl die Verwendung von Stylesheets für die
Verwaltung von Farben und anderen Designelementen vielversprechend war, stellte sich
heraus, dass die Nutzung des integrierten Scene Builders und der Übergang zu einem
regulären Fenster (Pane) )sich als effizienter erwies, um das endgültige Design zu erreichen,
das in Abbildung 2 dargestellt ist.

Abbildung 1 -Prototyp 1

Die Implementierung eines Fensters erleichterte die Anpassung der Größe von Schaltflächen
und Beschriftungen und verbesserte deren Gesamterscheinung. Außerdem wurde ein
Hintergrundbild eingefügt, um der Ansicht eine stärkere visuelle Wirkung zu verleihen.
Außerdem wurde die Deckkraft der Listenfarben reduziert, so dass die Benutzer das
gesamte Bild sehen können, bevor sie sich mit dem Programm beschäftigen. Insbesondere

Projektabschlussbericht 9 Praktikum PR2, SS 2023

wurden die Beschreibungen der Schaltflächen und Beschriftungen verbessert, um die
Benutzerfreundlichkeit für den Endbenutzer zu optimieren.

Abbildung 2 – Aktueller Stand

Hintergrundbild: Irina Iriser

Projektabschlussbericht 10 Praktikum PR2, SS 2023

3.4 ObservableList

Die Klasse ObservableList ist Teil des JavaFX-Collections-Frameworks und bietet eine
Listenimplementierung, mit der sich Änderungen an ihren Elementen verfolgen lassen. Sie
unterstützt Benachrichtigungen für Änderungen wie das Hinzufügen, Entfernen oder
Aktualisieren von Elementen, was wichtig ist, um die Benutzeroberfläche mit den zugrunde
liegenden Daten zu synchronisieren.

1. Controller:

In der Controller-Klasse werden `ObservableList`-Objekte verwendet, um die Daten an die

entsprechenden UI-Komponenten zu binden. Zum Beispiel:

• `listView1`, `listView2`, `listView3` und `listView4` werden mit der Methode `setItems`
an ihre jeweiligen `ListView`-Oberflächenkomponenten gebunden. Dadurch wird
sichergestellt, dass alle Änderungen an der `ObservableList` sofort in der
Benutzeroberfläche wiedergegeben werden.
• Die Methode `addTask` in der Controller-Klasse interagiert mit der `ObservableList`
`listView1`. Wenn ein Benutzer eine Aufgabe über die Benutzeroberfläche hinzufügt,
wird die eingegebene Aufgabe mit der Methode `add` der `ObservableList` zu
`listView1` hinzugefügt. Dies löst die Aktualisierung der Benutzeroberfläche aufgrund
der Bindung aus.
• Die Methode `retrieveItems` kombiniert die Daten von `listView2` und `listView3` und
füllt `listView4` auf. Sie holt die Daten aus den entsprechenden `ObservableList`-
Objekten und weist sie `listView4` zu.

2. Modell:

Die `ObservableList`-Objekte in der Model-Klasse (`listView1`, `listView2`, `listView3` und

`listView4`) dienen als Datenspeicher für die Anwendung.

• Die Methode `addTask` fügt Aufgaben zu `listView1` hinzu, indem sie die Methode
`add` der `ObservableList` aufruft. Diese Methode stellt sicher, dass die neue
Aufgabe zur Liste hinzugefügt wird und löst alle registrierten Listener aus, um die
Benutzeroberfläche zu aktualisieren.
• Die Methode `Drag` in der Model-Klasse behandelt die Drag-and-Drop-Funktionalität
zwischen `listView1`, `listView2` und `listView3`. Sie verwendet die `ObservableList`-
Projektabschlussbericht 11 Praktikum PR2, SS 2023
 Methoden wie `getItems`, `add` und `remove`, um die Daten als Reaktion auf die
Drag-and-Drop-Ereignisse zu manipulieren.
• Die Methode `retrieveItems` ruft Elemente aus `listView2` und `listView3` ab und
kombiniert sie in einem einzigen String-Format. Anschließend fügt sie die
kombinierten Elemente mit der Methode `add` von `ObservableList` zu `listView4`
hinzu. Dies löst die Aktualisierung der Benutzeroberfläche aus und spiegelt die
Änderungen in `listView4` wider.

3. View:

In der FXML-Datei werden die `ObservableList'-Objekte mit Hilfe des Attributs `fx:id` und des
Attributs `fx:controller` zur Angabe der zugehörigen Controller-Klasse an die UI-
Komponenten gebunden.
• Die `ListView'-UI-Komponenten (`listView1`, `listView2`, `listView3` und `listView4`)
sind mit den entsprechenden `ObservableList'-Objekten über das `fx:id'-Attribut
verbunden.
• Die Daten in der `ObservableList` werden in der Benutzeroberfläche durch diese
`ListView`-Komponenten angezeigt, und alle Änderungen, die an der
`ObservableList` vorgenommen werden, werden aufgrund der Bindung automatisch
in der Benutzeroberfläche widergespiegelt.

Insgesamt fungieren die "ObservableList"-Objekte als Vermittler zwischen den Komponenten

Controller, Model und View. Sie bieten ein Mittel zum Speichern, Bearbeiten und Beobachten
von Daten und stellen sicher, dass alle im Modell vorgenommenen Änderungen durch
Bindungen nahtlos in der Benutzeroberfläche wiedergegeben werden. Der Controller
interagiert mit den "ObservableList"-Objekten, um Daten zu aktualisieren oder abzurufen,
und die View zeigt die in der "ObservableList" enthaltenen Daten in den entsprechenden UI-
Komponenten an.

Projektabschlussbericht 12 Praktikum PR2, SS 2023

4 Algorithmus
4.1 UML-Diagramm

Die Abbildung 3 bietet einen Überblick über die architektonische Struktur und die
Interaktionen innerhalb der Daily Tracker-Anwendung. Es stellt die Beziehungen und
Abhängigkeiten zwischen den Hauptkomponenten der Anwendung dar, einschließlich
Modell, Ansicht und Controller. Das Diagramm hilft zu visualisieren, wie diese Komponenten
zusammenarbeiten, um den Datenfluss, die Benutzerinteraktion und die Anwendungslogik zu

Abbildung 3 – UML Diagramm

erleichtern.

Das Diagramm besteht aus drei Hauptkomponenten: Modell, Ansicht und Controller,
zusammen mit ihren jeweiligen Attributen und Methoden.

• Modell: Das Modell stellt die Daten und die Geschäftslogik der Anwendung
dar. Es enthält einen internen Zustand, der in privaten Feldern gekapselt ist,
und bietet Methoden zum Bearbeiten und Abrufen der Daten. Die Klasse

Projektabschlussbericht 13 Praktikum PR2, SS 2023

 Model ist für die Verwaltung der ObservableLists verantwortlich, die
aufgabenbezogene Informationen wie Aufgabenbeschreibungen und den
Abschlussstatus enthalten. Sie bietet auch Methoden für das Hinzufügen,
Löschen und Exportieren von Aufgaben.

• Ansicht: Die Ansicht stellt die grafische Benutzeroberfläche (GUI) der

Anwendung dar. Sie wird mit FXML definiert, einer Auszeichnungssprache für
die Gestaltung von JavaFX-Oberflächen. Die Ansicht besteht aus
verschiedenen UI-Elementen, darunter Beschriftungen, Textfelder,
Listenansichten und Schaltflächen, die für die Anzeige der Aufgabendaten und
die Interaktion mit ihnen verwendet werden. Die View ist für die visuelle
Darstellung der Daten für den Benutzer und die Erfassung der
Benutzereingaben verantwortlich.

• Steuerung: Der Controller fungiert als Vermittler zwischen den Komponenten

Model und View. Er verarbeitet Benutzeraktionen und aktualisiert das Modell
entsprechend. Die Controller-Klasse enthält Ereignisbehandlungsmethoden,
die durch Benutzerinteraktionen ausgelöst werden, z. B. Hinzufügen von
Aufgaben, Abrufen von Elementen, Exportieren in eine Textdatei, Löschen
von Aufgaben und Schließen der Anwendung. Der Controller initialisiert auch
das Model und stellt die notwendigen Bindungen zwischen den
ObservableLists des Models und den entsprechenden UI-Elementen in der
View her.

4.2 AddTask

Die Methode `addTask()` ruft den Text aus `textField1` ab, fügt ihn mit Hilfe eines Modells
als Aufgabe hinzu und löscht danach `textField1`. Diese Methode spielt eine entscheidende
Rolle in der Datenlogik, indem sie Benutzereingaben erfasst, verarbeitet und das Modell mit
der neuen Aufgabe aktualisiert, wodurch ein reibungsloser Arbeitsablauf für die Verwaltung
von Aufgaben innerhalb des Programms gewährleistet wird. Sie wurde unabhängig
entwickelt, ohne externe Ressourcen zu nutzen.

Projektabschlussbericht 14 Praktikum PR2, SS 2023

4.3 Drag and Drop

Die Methode `Drag` implementiert die Funktion des Ziehens und Ablegens zwischen drei
Listenansichten: `listView1`, `listView2` und `listView3`. Der Code enthält drei Event-Handler,
die das Verhalten in verschiedenen Stadien des Drag-and-Drop-Prozesses definieren.

Der erste Event-Handler, `listView1.setOnDragDetected`, wird ausgelöst, wenn der Benutzer

eine Drag-Operation auf `listView1` initiiert. Er beginnt den Drag-and-Drop-Prozess, indem er
ein `Dragboard` erstellt und dessen Inhalt auf das ausgewählte Element von `listView1`
setzt.

Der zweite Event-Handler, `listView2.setOnDragOver`, wird aufgerufen, wenn ein Element

über `listView2` gezogen wird. Er überprüft, ob die Quelle des Ziehens nicht `listView2`
selbst ist und ob das `Dragboard` einen String enthält. Wenn beide Bedingungen erfüllt sind,
wird der Übertragungsmodus für den Ziehvorgang akzeptiert.

Der dritte Event-Handler, `listView2.setOnDragDropped`, wird ausgeführt, wenn ein Element

auf `listView2` gezogen wird. Er holt den Inhalt vom `Dragboard` und prüft, ob er eine
Zeichenkette enthält. Wenn ja, fügt es das gezogene Element zu `listView2` hinzu, entfernt
es aus `listView1` und fügt die aktuelle Zeit am Anfang von `listView3` ein. Das Erfolgsflag
wird auf der Grundlage des Abschlussstatus der Operation gesetzt.

Es ist erwähnenswert, dass Oracle eine Schritt-für-Schritt-Implementierungsanleitung für

eine ähnliche Funktionalität veröffentlicht hat, die weitere Einblicke in den Prozess geben
könnte. ChatGPT nahm Anpassungen am Code vor, um Fehler zu beheben und den Code
zu ergänzen. (Fedortsova, 2013) (ChatGPT, 2023)

4.4 Timestamp

Innerhalb der Methode wird die Funktion LocalDateTime.now() verwendet, um die aktuellen
Datums- und Zeitinformationen zu erhalten. Dieses LocalDateTime-Objekt enthält das
genaue Datum und die Uhrzeit zum Zeitpunkt des Aufrufs der Methode.

Im nächsten Schritt wird das currentTime-Objekt mithilfe von

DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") in ein bestimmtes Muster formatiert.

Projektabschlussbericht 15 Praktikum PR2, SS 2023

Das Muster "yyyy-MM-dd HH:mm:ss" gibt das gewünschte Format an, einschließlich Jahr,
Monat, Tag, Stunde, Minute und Sekunde.

Es ist erwähnenswert, dass Oracle eine Schritt-für-Schritt-Implementierungsanleitung für

eine ähnliche Funktionalität veröffentlicht hat, die weitere Einblicke in den Prozess geben
könnte. ChatGPT nahm Anpassungen am Code vor, um Fehler zu beheben und den Code
zu ergänzen. (Oracle, kein Datum) (ChatGPT, 2023)

4.5 Retrieve Items

Diese Methode ruft Elemente aus zwei separaten Listen, `listView2` und `listView3`, ab,
kombiniert sie zu einem neuen Format und fügt die kombinierten Elemente zu `listView4`
hinzu.

Zunächst erhält der Code die Verweise auf `listView2` und `listView3` über die Methoden
`getListView2()` bzw. `getListView3()`, die vermutlich die mit den jeweiligen Listenansichten
verbundenen beobachtbaren Listen zurückgeben.

Als nächstes wird die Anzahl der abzurufenden Elemente auf der Grundlage der
Mindestgröße zwischen `listView2Items` und `listView3Items` bestimmt.
Dann werden in einer Schleife die Elemente an den entsprechenden Indizes aus beiden
Listen abgerufen, mit einem Trennzeichen ("/") verkettet und das kombinierte Element mit
der Methode `add()` zu `listView4` hinzugefügt. Schließlich wird der Inhalt von `listView2`
und `listView3` mit der Methode `clear()` gelöscht.

Diese Methode wurde mit ChatGPT in seiner Gesamtheit entwickelt.

4.6 Import

Diese Methode exportiert Elemente aus `listView4` in eine Textdatei, die durch den
Parameter `filePath` angegeben wird. Innerhalb der Methode wird ein `BufferedWriter`
erstellt und mit einem neuen `FileWriter` initialisiert, um in die angegebene Datei zu
schreiben.

Dann werden die Elemente in `listView4` in einer for-each-Schleife durchlaufen. Jeder

Eintrag wird mit der Methode `write()` des `BufferedWriter` in die Datei geschrieben, gefolgt
von einer neuen Zeile mit `writer.newLine()`, um die Einträge zu trennen.
Projektabschlussbericht 16 Praktikum PR2, SS 2023
Wenn der Exportvorgang erfolgreich ist, wird eine Meldung auf der Konsole ausgegeben, die
den Dateipfad angibt, in den die Elemente exportiert wurden. Tritt während des
Exportvorgangs eine `IOException` auf, wird stattdessen eine Fehlermeldung ausgegeben,
die auch die spezifische Ausnahmemeldung enthält. (Singh, kein Datum) (ChatGPT, 2023)

4.7 Future Work

Die Daily Tracker-Anwendung kann in verschiedenen Aspekten verbessert werden, um ihre

Funktionalität, Benutzerfreundlichkeit und Wartbarkeit zu steigern. Diese Vorschläge zielen
darauf ab, die Daily Tracker-Anwendung robuster und benutzerfreundlicher zu gestalten.
Zum Beispiel:

1. Datenpersistenz: Um die Aufgabendaten über Anwendungssitzungen hinweg zu

speichern, wird ein Mechanismus zur dauerhaften Speicherung in einer Datenbank
oder einem Dateispeicher implementiert.
2. Benutzerauthentifizierung: Eine Benutzerauthentifizierungsfunktion wird hinzugefügt,
um mehreren Benutzern individuelle Aufgabenlisten zu ermöglichen. Mechanismen
zur Benutzerregistrierung, -anmeldung und -authentifizierung werden implementiert,
um Datenschutz und -sicherheit zu gewährleisten.
3. Aufgabenkategorisierung und -filterung: Die Möglichkeiten der Aufgabenverwaltung
werden erweitert, indem Kategorien oder Etiketten für Aufgaben eingeführt werden.
Benutzern wird ermöglicht, Aufgaben Kategorien zuzuweisen, und es werden
Filteroptionen bereitgestellt, um Aufgaben basierend auf ihren Kategorien
anzuzeigen.
4. Aufgabenpriorisierung und Erinnerungen: Funktionen zur Priorisierung von Aufgaben,
wie das Setzen von Fristen oder Prioritäten, werden eingeführt.
Erinnerungsbenachrichtigungen oder Warnungen informieren Benutzer über nahende
Aufgabenfristen.
5. Anpassung durch Ziehen und Ablegen: Die Zieh- und Ablegefunktionalität wird
verbessert, indem Benutzern die Möglichkeit gegeben wird, die Reihenfolge oder
Anordnung der Aufgaben innerhalb der Listenansichten anzupassen. Eine Drag-and-
Drop-Funktion zur Neuordnung ermöglicht es den Benutzern, ihre Aufgaben nach
ihren Präferenzen zu organisieren.
6. Datenvalidierung und Fehlerbehandlung: In der gesamten Anwendung werden
angemessene Mechanismen zur Datenvalidierung und Fehlerbehandlung
implementiert. Benutzereingaben werden validiert, potenzielle Ausnahmen behandelt
Projektabschlussbericht 17 Praktikum PR2, SS 2023
 und aussagekräftige Fehlermeldungen bereitgestellt, um Benutzer bei Fehleingaben
oder Anwendungsfehlern anzuleiten.
7. UI-Verbesserungen: Die Benutzeroberfläche und das Benutzererlebnis werden durch
visuelle Verbesserungen optimiert. Dies beinhaltet die Verwendung einheitlicher
Themen, responsiver Layouts und intuitiver Symbole. Die Integration von
Animationen oder Übergängen kann die Anwendung ansprechender und
benutzerfreundlicher gestalten.

Projektabschlussbericht 18 Praktikum PR2, SS 2023

5 Referenzen
Azul. (11. Oktober 2021). docs.azul. Von Azul Zulu 17 General Availability Release Notes:
https://docs.azul.com/core/zulu-openjdk/release-notes/17-ga abgerufen
ChatGPT. (Juni 2023). Von https://chat.openai.com/share/457124d4-b087-487a-9e00-
0c2c86276e57 abgerufen
Fedortsova, I. (Juni 2013). Oracle. Von Drag-and-Drop Feature in JavaFX Applications:
https://docs.oracle.com/javafx/2/drag_drop/jfxpub-drag_drop.htm abgerufen
Oracle. (kein Datum). Packages Overview. Von
https://docs.oracle.com/javase/8/javafx/api/overview-summary.html abgerufen
Singh, C. (kein Datum). BeginnersBook. Von How to write to file in Java using BufferedWriter:
https://beginnersbook.com/2014/01/how-to-write-to-file-in-java-using-
bufferedwriter/ abgerufen
Vats, R. (21. September 2020). upGrad. Von Java MVC Project [Step-By-Step Process
Explained]: https://www.upgrad.com/blog/java-mvc-project/ abgerufen

Es ist zu beachten, dass ChatGPT während des gesamten Projekts zur Verfeinerung
und Beantwortung von Fragen während der Entwicklung genutzt wurde. Die
Hauptkonversation, die die Ausarbeitung aller wichtigen Funktionen umfasst, ist unter
dem oben angegebenen Link zu finden. Dieser Link steht jedem zur Verfügung, der
die Konversation nachlesen möchte.

Projektabschlussbericht 19 Praktikum PR2, SS 2023

6 Anhang A – Quellcode
6.1 Modell – Quellcode

Projektabschlussbericht 20 Praktikum PR2, SS 2023

Projektabschlussbericht 21 Praktikum PR2, SS 2023
Projektabschlussbericht 22 Praktikum PR2, SS 2023
Projektabschlussbericht 23 Praktikum PR2, SS 2023
Projektabschlussbericht 24 Praktikum PR2, SS 2023
6.2 Controller – Quellcode

Projektabschlussbericht 25 Praktikum PR2, SS 2023

Projektabschlussbericht 26 Praktikum PR2, SS 2023
6.3 View – Quellcode

Projektabschlussbericht 27 Praktikum PR2, SS 2023

Projektabschlussbericht 28 Praktikum PR2, SS 2023
Projektabschlussbericht 29 Praktikum PR2, SS 2023
Projektabschlussbericht 30 Praktikum PR2, SS 2023
Projektabschlussbericht 31 Praktikum PR2, SS 2023
6.4 Main – Quellcode

Projektabschlussbericht 32 Praktikum PR2, SS 2023