letzte Verbesserungen, UML-Diagramme hinzugefügt

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

LibrarySystem/UI/BibliothekTest.java

@@ -0,0 +1,15 @@
+package LibrarySystem.UI;
+
+import LibrarySystem.domain.benutzern.*;
+import LibrarySystem.facade.BibliothekSystem;
+
+public class BibliothekTest {
+
+    public static void main(String[] args) {
+        BibliothekSystem system = new BibliothekSystem();
+
+        // UI starten
+        UI ui = new UI(system);
+        ui.starten();
+    }
+}

LibrarySystem/UI/UI.java

@@ -0,0 +1,148 @@
+package LibrarySystem.UI;
+
+import LibrarySystem.domain.benutzern.*;
+import LibrarySystem.facade.BibliothekSystem;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Scanner;
+
+public class UI {
+    private BibliothekSystem system;
+    private Scanner scanner;
+
+    public UI(BibliothekSystem system) {
+        this.system = system;
+        this.scanner = new Scanner(System.in);
+    }
+
+    public void starten() {
+        while (true) {
+            System.out.println("Willkommen in der Bibliothek!\n");
+            System.out.println("1. Anmelden");
+            System.out.println("2. Medien durchsuchen");
+            System.out.println("3. Ausleihen eines Mediums");
+            System.out.println("4. Rückgabe eines Mediums");
+            System.out.println("5. Zeige ausgeliehene Medien und Gebühren");
+            System.out.println("6. Verlängern der Leihfrist");
+            System.out.println("7. Admin-Login (Überfällige Gebühren verbuchen)");
+            System.out.println("8. Systemdatum manuell ändern");
+            System.out.println("0. Beenden\n");
+            System.out.print("Bitte wählen Sie eine Option: ");
+            int auswahl = scanner.nextInt();
+            scanner.nextLine();
+
+            switch (auswahl) {
+                case 1 -> anmelden();
+                case 2 -> durchsuchenMedien();
+                case 3 -> ausleihenMedium();
+                case 4 -> rueckgabeMedium();
+                case 5 -> zeigeAusgelieheneMedienUndGebuehren();
+                case 6 -> verlaengernLeihfrist();
+                case 7 -> adminLogin();
+                case 8 -> aendernDatumManuell();
+                case 0 -> {
+                    System.out.println("Auf Wiedersehen!");
+                    return;
+                }
+                default -> System.out.println("Ungültige Auswahl, bitte erneut versuchen.");
+            }
+        }
+    }
+
+    //1. Anmelden
+    private void anmelden() {
+        System.out.print("Bitte geben Sie Ihre Kartennummer ein: ");
+        String kartennummer = scanner.nextLine();
+        Benutzer benutzer = system.anmelden(kartennummer);
+        if (benutzer != null) {
+            System.out.println("Willkommen! Erfolgreich angemeldet als: " + benutzer.getName() + ".");
+        } else {
+            System.out.println("Flasche Kartennummer. Bitte erneut versuchen!");
+        }
+    }
+
+    //2. Medien durchsuchen
+    private void durchsuchenMedien() {
+        System.out.println("Durchsuchen der Medien: (bitte nur Titel und Medienart eingeben)");
+        System.out.println("Titel: ");
+        String titel = scanner.nextLine();
+        System.out.println("Medienart: ");
+        String medienart = scanner.nextLine();
+        system.durchsuchenMedien(titel, medienart);
+    }
+
+    //3. Ausleihe eines Mediums
+    private void ausleihenMedium() {
+        System.out.println("Bitte melden Sie sich mit der Kartennummer ein: ");
+        String kartennummer = scanner.nextLine();
+        System.out.print("Bitte geben Sie die ID des Mediums ein, das Sie ausleihen möchten: ");
+        String mediumID = scanner.nextLine();
+        system.ausleiheMedium(kartennummer, mediumID);
+    }
+
+    //4. Rückgabe eines Mediums
+    private void rueckgabeMedium() {
+        System.out.print("Bitte geben Sie die ID des Mediums ein, das Sie zurückgeben möchten: ");
+        String mediumId = scanner.nextLine();
+        system.rueckgabeMedium(mediumId);
+    }
+
+    //5. Zeige ausgeliehene Medien und Gebühren
+    private void zeigeAusgelieheneMedienUndGebuehren() {
+        System.out.print("Bitte geben Sie Ihre Kartennummer ein: ");
+        String kartennummer = scanner.nextLine();
+        Benutzer benutzer = system.anmelden(kartennummer);
+        if (benutzer != null) {
+            system.zeigeGebuehrenkonto(kartennummer);
+            benutzer.anzeigenAusleihen();
+        }
+    }
+
+    //6. Verlängern der Leihfrist
+    private void verlaengernLeihfrist() {
+        System.out.println("Bitte melden Sie sich mit der Kartennummer ein: ");
+        String kartennummer = scanner.nextLine();
+        System.out.print("Bitte geben Sie die ID des Mediums ein, dessen Leihfrist Sie verlängern möchten: ");
+        String mediumId = scanner.nextLine();
+        system.verlaengernMedium(kartennummer,mediumId);
+    }
+
+    //7. Admin-Login
+    private void adminLogin() {
+        System.out.print("Bitte geben Sie Ihre Admin-Kartennummer ein: ");
+        String kartennummer = scanner.nextLine();
+        Benutzer admin = system.anmelden(kartennummer);
+        if (admin instanceof Admin) {
+            System.out.println("Admin erfolgreich eingeloggt.");
+            System.out.print("Bitte geben Sie die Kartennummer des Benutzers ein, dessen Gebühren Sie verbuchen möchten: ");
+            String benutzerKartennummer = scanner.nextLine();
+            Benutzer benutzer = system.anmelden(benutzerKartennummer);
+            if (benutzer != null) {
+                ((Admin) admin).bestaetigeGebuehrenzahlung(benutzer);
+            }
+        } else {
+            System.out.println("Ungültige Admin-Kartennummer.");
+        }
+    }
+
+    //Methode zur manuellen Änderung des Datums für Testen
+    //Von AI generiert
+    private void aendernDatumManuell(){
+        System.out.println("Neues Datum eingeben (Format: yyyy-MM-dd)");
+        String datum = scanner.nextLine();
+        try{
+            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
+            Date neuesDatum = formatter.parse(datum);
+            system.setAktuellesDatum(neuesDatum);
+        } catch (ParseException e) {
+            System.out.println("Üngultiges Datum.");
+        }
+    }
+
+
+}
+
+
+

LibrarySystem/andereDateien/KIchatGPT/prompt1.txt

@@ -0,0 +1,13 @@
+ich: Erstelle mir eine Methode findeMedium, die in einer Liste mit Medien ein bestimmtes, vom Benutzer eingegebenen Medium
+findet. Benutze dabei Lambda-Ausdrücke
+
+AI: hier ist die Methode findeMedium, in einer Liste von Medien nach einem bestimmten, vom Benutzer eingegebenen Medium
+findet:
+
+//Methode zum Finden eines Mediums
+    public Medium findeMedium(String ID) {
+        return medienListe.stream()
+                .filter(m -> m.getID().equals(ID))
+                .findFirst()
+                .orElse(null);
+    }

LibrarySystem/andereDateien/KIchatGPT/prompt2+3.txt

@@ -0,0 +1,220 @@
+prompt 2:
+
+ich: erstelle eine Methode overdueGebuehren, die die überfälligen Gebühren berechnet. hier ist die Einsatzklasse
+(Klasse BibliothekSystem):
+
+AI: Methode: calculateOverdueFee
+    Diese Methode berechnet die überfälligen Gebühren basierend auf den Anzahl der überfälligen Tage.
+    Die Berechnung erfolgt nach einer einfachen Regel: 0,50 EUR pro überfälligem Tag.
+
+    Code
+    java
+
+    // Berechnung der Gebühren für überfällige Medien
+    private double calculateOverdueFee(long overdueDays) {
+        return overdueDays * 0.50; // Beispiel: 0,50 EUR pro Tag
+    }
+
+
+    Einsatzort
+    Die Methode wird innerhalb von returnMedium aufgerufen, um die Gebühren zu berechnen:
+
+    java
+    if (currentDate.after(medium.getDueDate())) {
+        long overdueDays = (currentDate.getTime() - medium.getDueDate().getTime()) / (1000 * 60 * 60 * 24);
+        double fee = calculateOverdueFee(overdueDays);
+        System.out.println("Überfällige Gebühren für " + borrower.getName() + ": " + fee + " EUR.");
+    }
+
+    Einbindung in die LibrarySystem-Klasse
+    Die Methode ist eine private Hilfsmethode der LibrarySystem-Klasse, da sie nur für interne Berechnungen verwendet wird.
+     Sie ist bewusst einfach gehalten, kann aber bei Bedarf erweitert werden,
+     z. B. um unterschiedliche Gebühren für verschiedene Medientypen oder Benutzerkategorien zu berücksichtigen.
+
+-----------------------------------------------------------
+prompt 3:
+
+ich: Das System soll überfällige Artikel verfolgen und Säumnisgebühren berechnen: • Für jeden Tag, an dem ein Gegenstand
+ überfällig ist, wird eine Gebühr von 1€ erhoben. • Nach 7 Tagen Überfälligkeit erhöht sich die Gebühr auf 2€ pro Tag.
+ Das System sollte den Benutzern die Gesamtgebühren jedes Mal anzeigen, wenn sie sich anmelden, einen Artikel ausleihen
+ oder zurückgeben.
+
+ AI: Um diese Anforderungen umzusetzen, wird das Bibliotheksverwaltungssystem wie folgt erweitert:
+
+     1. Überarbeitung von calculateOverdueFee
+     Die Methode calculateOverdueFee wird angepasst, um die gestaffelten Gebühren zu berücksichtigen:
+
+     java
+     Copy code
+     private double calculateOverdueFee(long overdueDays) {
+         if (overdueDays <= 0) {
+             return 0; // Keine Gebühren, wenn nicht überfällig
+         }
+
+         if (overdueDays <= 7) {
+             return overdueDays * 1.0; // 1€ pro Tag für die ersten 7 Tage
+         }
+
+         return (7 * 1.0) + ((overdueDays - 7) * 2.0); // 2€ pro Tag ab dem 8. Tag
+     }
+     2. Verfolgung von Gebühren pro Benutzer
+     Die Klasse User wird erweitert, um aufgelaufene Gebühren zu speichern und zu verwalten:
+
+     Anpassung der User-Klasse
+     java
+     Copy code
+     public class User {
+         private String id;
+         private String name;
+         private List<Medium> borrowedItems;
+         private double outstandingFees; // Aufgelaufene Gebühren
+
+         public User(String id, String name) {
+             this.id = id;
+             this.name = name;
+             this.borrowedItems = new ArrayList<>();
+             this.outstandingFees = 0.0;
+         }
+
+         public double getOutstandingFees() {
+             return outstandingFees;
+         }
+
+         public void addFee(double fee) {
+             this.outstandingFees += fee;
+         }
+
+         public void clearFees() {
+             this.outstandingFees = 0.0;
+         }
+
+         public void listBorrowedItems() {
+             if (borrowedItems.isEmpty()) {
+                 System.out.println("Keine ausgeliehenen Medien.");
+             } else {
+                 System.out.println("Ausgeliehene Medien:");
+                 for (Medium medium : borrowedItems) {
+                     System.out.println("- " + medium.getTitle() + " (Rückgabedatum: " + medium.getDueDate() + ")");
+                 }
+             }
+         }
+
+         // Weitere Methoden für Ausleihen und Rückgabe wie bereits implementiert
+     }
+     3. Gebührenberechnung bei Rückgabe
+     Die Methode returnMedium wird angepasst, um aufgelaufene Gebühren direkt in der Benutzerinstanz zu speichern:
+
+     java
+     Copy code
+     public void returnMedium(String mediumId) {
+         Medium medium = findMedium(mediumId);
+         if (medium == null) {
+             System.out.println("Medium mit der ID '" + mediumId + "' wurde nicht gefunden.");
+             return;
+         }
+
+         if (!medium.isLoaned()) {
+             System.out.println("Medium '" + medium.getTitle() + "' ist nicht ausgeliehen.");
+             return;
+         }
+
+         User borrower = null;
+         for (User user : userManager.getUsers()) {
+             if (user.getBorrowedItems().contains(medium)) {
+                 borrower = user;
+                 break;
+             }
+         }
+
+         if (borrower == null) {
+             System.out.println("Kein Benutzer gefunden, der dieses Medium ausgeliehen hat.");
+             return;
+         }
+
+         borrower.returnItem(medium);
+
+         // Überfällige Gebühren berechnen
+         if (currentDate.after(medium.getDueDate())) {
+             long overdueDays = (currentDate.getTime() - medium.getDueDate().getTime()) / (1000 * 60 * 60 * 24);
+             double fee = calculateOverdueFee(overdueDays);
+             borrower.addFee(fee);
+             System.out.println("Medium '" + medium.getTitle() + "' wurde erfolgreich zurückgegeben.");
+             System.out.println("Überfällige Gebühren für " + borrower.getName() + ": " + fee + " EUR.");
+         } else {
+             System.out.println("Medium '" + medium.getTitle() + "' wurde rechtzeitig zurückgegeben.");
+         }
+
+         // Verbleibende ausgeliehene Medien anzeigen
+         System.out.println("Verbleibende ausgeliehene Medien von " + borrower.getName() + ":");
+         borrower.listBorrowedItems();
+     }
+     4. Gebührenanzeige bei Anmeldung
+     Eine Methode wird hinzugefügt, um die Gebühren eines Benutzers bei der Anmeldung anzuzeigen:
+
+     java
+     Copy code
+     public void showOutstandingFees(String userId) {
+         User user = userManager.getUser(userId);
+         if (user == null) {
+             System.out.println("Benutzer nicht gefunden.");
+             return;
+         }
+
+         double fees = user.getOutstandingFees();
+         if (fees > 0) {
+             System.out.println("Offene Gebühren für " + user.getName() + ": " + fees + " EUR.");
+         } else {
+             System.out.println("Keine offenen Gebühren für " + user.getName() + ".");
+         }
+     }
+     5. Gebührenzahlung durch Admin
+     Ein Admin-Benutzer wird hinzugefügt, der Zahlungen bearbeiten kann:
+
+     Admin-Klasse
+     java
+     Copy code
+     public class Admin extends User {
+         public Admin(String id, String name) {
+             super(id, name);
+         }
+
+         public void processPayment(User user, double amount) {
+             if (amount <= 0) {
+                 System.out.println("Ungültiger Zahlungsbetrag.");
+                 return;
+             }
+
+             if (amount > user.getOutstandingFees()) {
+                 System.out.println("Betrag übersteigt offene Gebühren.");
+                 return;
+             }
+
+             user.addFee(-amount); // Reduziert die Gebühren
+             System.out.println("Zahlung von " + amount + " EUR für " + user.getName() + " erfolgreich bearbeitet.");
+             System.out.println("Verbleibende Gebühren: " + user.getOutstandingFees() + " EUR.");
+         }
+     }
+     Gebührenzahlung
+     Die Benutzeroberfläche wird um eine Option für Admins ergänzt:
+
+     java
+     Copy code
+     case 6 -> {
+         System.out.print("Admin-ID: ");
+         String adminId = scanner.next();
+         User admin = userManager.getUser(adminId);
+         if (admin instanceof Admin) {
+             System.out.print("Benutzer-ID: ");
+             String userId = scanner.next();
+             User user = userManager.getUser(userId);
+             if (user == null) {
+                 System.out.println("Benutzer nicht gefunden.");
+                 break;
+             }
+             System.out.print("Zahlungsbetrag: ");
+             double amount = scanner.nextDouble();
+             ((Admin) admin).processPayment(user, amount);
+         } else {
+             System.out.println("Keine Admin-Rechte.");
+         }
+     }

LibrarySystem/andereDateien/KIchatGPT/prompt4+5.txt

@@ -0,0 +1,173 @@
+prompt 4:
+
+ich: implementiere einen weiteren punkt in die ui, der eine manuelle systemdatumänderung erlaubt,
+um die rückgabe mit gebührenkonto ausprobieren zu können. Hier ist die UI Klasse (Eingabe von UI Klasse)
+
+AI:Um eine manuelle Änderung des Systemdatums in der Benutzeroberfläche zu ermöglichen, müssen folgende Schritte durchgeführt werden:
+
+   1. Hinzufügen eines Systemdatums
+   Ein globales Systemdatum wird hinzugefügt, das in der gesamten Anwendung verwendet wird. Dies ermöglicht es, das Datum manuell zu ändern.
+
+   Hinzufügen zur LibrarySystem-Klasse
+   java
+   Copy code
+   import java.util.Calendar;
+   import java.util.Date;
+
+   public class LibrarySystem {
+       private Date currentDate;
+
+       public LibrarySystem() {
+           this.currentDate = new Date(); // Standardmäßig aktuelles Datum
+       }
+
+       public Date getCurrentDate() {
+           return currentDate;
+       }
+
+       public void setCurrentDate(Date date) {
+           this.currentDate = date;
+           System.out.println("Systemdatum erfolgreich auf " + date + " geändert.");
+       }
+
+       public void resetCurrentDate() {
+           this.currentDate = new Date();
+           System.out.println("Systemdatum auf aktuelles Datum zurückgesetzt: " + currentDate);
+       }
+   }
+   2. Anpassung der Berechnungen
+   Die Methoden, die auf das aktuelle Datum angewiesen sind (z. B. Rückgabefristen und Gebührenberechnung), nutzen nun das globale currentDate.
+
+   Beispiel: returnMedium
+   java
+   Copy code
+   if (currentDate.after(medium.getDueDate())) {
+       long overdueDays = (currentDate.getTime() - medium.getDueDate().getTime()) / (1000 * 60 * 60 * 24);
+       double fee = calculateOverdueFee(overdueDays);
+       borrower.addFee(fee);
+       System.out.println("Medium '" + medium.getTitle() + "' wurde erfolgreich zurückgegeben.");
+       System.out.println("Überfällige Gebühren für " + borrower.getName() + ": " + fee + " EUR.");
+   }
+   3. Erweiterung der Benutzeroberfläche
+   Eine neue Option wird hinzugefügt, um das Datum manuell zu ändern oder zurückzusetzen.
+
+   Code für die UI:
+   java
+   Copy code
+   case 7 -> {
+       System.out.println("Systemdatum ändern:");
+       System.out.println("1. Manuelles Datum setzen");
+       System.out.println("2. Datum auf aktuelles zurücksetzen");
+       int option = scanner.nextInt();
+
+       switch (option) {
+           case 1 -> {
+               System.out.print("Neues Datum eingeben (Format: yyyy-MM-dd): ");
+               String dateInput = scanner.next();
+               try {
+                   SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
+                   Date newDate = dateFormat.parse(dateInput);
+                   librarySystem.setCurrentDate(newDate);
+               } catch (ParseException e) {
+                   System.out.println("Ungültiges Datum. Bitte im Format yyyy-MM-dd eingeben.");
+               }
+           }
+           case 2 -> librarySystem.resetCurrentDate();
+           default -> System.out.println("Ungültige Option.");
+       }
+   }
+---------------------------------------------------------------------
+prompt 5:
+
+ich: das rückgabeDatum wird bei mir so berechnet, sodass immer das systemdatum verwendet wird. kannst du das so verbessern,
+so dass es auch mit dem manuellen Datum funktioniert? public Date rechneRueckgabedatum(){
+             Calendar calendar = Calendar.getInstance();
+             calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer());
+             this.rueckgabedatum = calendar.getTime();
+             return rueckgabedatum;
+         }
+AI:
+     Um sicherzustellen, dass die Methode rechneRueckgabedatum mit dem manuellen Systemdatum arbeitet, anstatt immer
+     das aktuelle Datum zu verwenden, können wir das globale Systemdatum aus der LibrarySystem-Klasse einbinden.
+     Dazu müssen wir das Systemdatum explizit in die Berechnung einfließen lassen.
+
+     Verbesserte Implementierung der Methode
+     java
+     Copy code
+     public Date rechneRueckgabedatum(Date systemDate) {
+         Calendar calendar = Calendar.getInstance();
+         calendar.setTime(systemDate); // Verwende das übergebene Systemdatum
+         calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer()); // Füge die Ausleihdauer hinzu
+         this.rueckgabedatum = calendar.getTime();
+         return rueckgabedatum;
+     }
+     Anpassung der Aufrufe
+     Damit die Methode korrekt funktioniert, muss das Systemdatum beim Aufruf übergeben werden. Beispielsweise:
+
+     Ausleihe eines Mediums
+     Wenn ein Medium ausgeliehen wird, rufst du rechneRueckgabedatum mit dem aktuellen Systemdatum auf:
+
+     java
+     Copy code
+     public void leiheMediumAus(Medium medium) {
+         if (medium.isLoaned()) {
+             System.out.println("Das Medium '" + medium.getTitle() + "' ist bereits ausgeliehen.");
+             return;
+         }
+
+         Date rueckgabeDatum = medium.rechneRueckgabedatum(librarySystem.getCurrentDate());
+         medium.setLoaned(true);
+         medium.setDueDate(rueckgabeDatum);
+         System.out.println("Medium '" + medium.getTitle() + "' erfolgreich ausgeliehen.");
+         System.out.println("Rückgabedatum: " + rueckgabeDatum);
+     }
+     Alternative: Systemdatum global bereitstellen
+     Falls viele Klassen das Systemdatum verwenden, kannst du es direkt über eine Singleton-Instanz der LibrarySystem-Klasse bereitstellen:
+
+     Singleton-Pattern für LibrarySystem
+     java
+     Copy code
+     public class LibrarySystem {
+         private static LibrarySystem instance;
+         private Date currentDate;
+
+         private LibrarySystem() {
+             this.currentDate = new Date();
+         }
+
+         public static LibrarySystem getInstance() {
+             if (instance == null) {
+                 instance = new LibrarySystem();
+             }
+             return instance;
+         }
+
+         public Date getCurrentDate() {
+             return currentDate;
+         }
+
+         public void setCurrentDate(Date date) {
+             this.currentDate = date;
+         }
+
+         public void resetCurrentDate() {
+             this.currentDate = new Date();
+         }
+     }
+     Aufruf ohne Übergabe des Datums
+     Wenn die Methode auf das Singleton zugreifen kann, wird die Übergabe des Datums überflüssig:
+
+     java
+     Copy code
+     public Date rechneRueckgabedatum() {
+         Calendar calendar = Calendar.getInstance();
+         calendar.setTime(LibrarySystem.getInstance().getCurrentDate());
+         calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer());
+         this.rueckgabedatum = calendar.getTime();
+         return rueckgabedatum;
+     }
+     Zusammenfassung der Änderungen
+     Neue Methode: Die Methode rechneRueckgabedatum akzeptiert jetzt ein systemDate als Parameter.
+     Systemweite Änderungen: Das Systemdatum wird durch die LibrarySystem-Klasse verwaltet.
+     Globale Verfügbarkeit: Entweder durch explizite Übergabe oder über ein Singleton-Pattern.
+     Mit diesen Änderungen passt sich das Rückgabedatum automatisch an das manuelle Systemdatum an.

LibrarySystem/andereDateien/KIchatGPT/prompt6.txt

@@ -0,0 +1,123 @@
+
+ich: wie kann ich die jährliche Gebühren, die jeweils in den klassen Erwachsener und Student als final JAHRESGEBUEHREN,
+mit in das gebührenkonto mitrechnen
+
+AI: Um die jährlichen Gebühren (JAHRESGEBUEHREN) aus den Klassen Erwachsener und Student in das Gebührenkonto eines
+Benutzers einzurechnen, kannst du folgende Schritte unternehmen:
+
+1. Änderungen in den Klassen Erwachsener und Student
+Die Klassen sollten eine Methode bereitstellen, um die jährlichen Gebühren abzurufen. Wenn sie final sind, kann dies einfach ein Getter sein.
+
+Beispiel: Klasse Erwachsener
+java
+Copy code
+public class Erwachsener extends Benutzer {
+    public static final double JAHRESGEBUEHREN = 50.0; // Beispielwert
+
+    @Override
+    public double getJahresgebuehren() {
+        return JAHRESGEBUEHREN;
+    }
+}
+Beispiel: Klasse Student
+java
+Copy code
+public class Student extends Benutzer {
+    public static final double JAHRESGEBUEHREN = 25.0; // Beispielwert
+
+    @Override
+    public double getJahresgebuehren() {
+        return JAHRESGEBUEHREN;
+    }
+}
+2. Anpassung der Basisklasse Benutzer
+In der Basisklasse Benutzer solltest du eine Methode getJahresgebuehren() deklarieren, die von den Unterklassen überschrieben wird.
+
+Klasse Benutzer
+java
+Copy code
+public abstract class Benutzer {
+    private double gebuehrenkonto; // Das Konto, das alle Gebühren summiert
+
+    public Benutzer() {
+        this.gebuehrenkonto = 0.0; // Initialisierung
+    }
+
+    // Abstrakte Methode, die von Unterklassen implementiert wird
+    public abstract double getJahresgebuehren();
+
+    // Methode, um Gebühren hinzuzufügen
+    public void addGebuehren(double betrag) {
+        this.gebuehrenkonto += betrag;
+    }
+
+    // Methode, um das Gebührenkonto abzurufen
+    public double getGebuehrenkonto() {
+        return gebuehrenkonto;
+    }
+
+    // Methode, um die Jahresgebühr hinzuzufügen
+    public void berechneJahresgebuehren() {
+        addGebuehren(getJahresgebuehren());
+    }
+}
+3. Automatische Einrechnung der Jahresgebühren
+Du kannst sicherstellen, dass die jährlichen Gebühren beim Erstellen eines Benutzers automatisch eingerechnet werden,
+oder sie beim Jahreswechsel explizit einberechnen.
+
+Beispiel: Automatische Berechnung bei Benutzererstellung
+Passe die Konstruktoren der Unterklassen an, um die Jahresgebühren direkt hinzuzufügen:
+
+java
+Copy code
+public class Erwachsener extends Benutzer {
+    public static final double JAHRESGEBUEHREN = 50.0;
+
+    public Erwachsener() {
+        super(); // Ruft den Konstruktor von Benutzer auf
+        berechneJahresgebuehren(); // Hinzufügen der Jahresgebühr
+    }
+
+    @Override
+    public double getJahresgebuehren() {
+        return JAHRESGEBUEHREN;
+    }
+}
+4. Beispiel für manuelle Einrechnung bei Jahreswechsel
+Wenn die Jahresgebühren zu einem bestimmten Zeitpunkt eingerechnet werden sollen, kannst du eine Methode
+in der Klasse BibliothekSystem hinzufügen:
+
+Methode in BibliothekSystem
+java
+Copy code
+public void berechneJahresgebuehrenFuerAlleBenutzer(List<Benutzer> benutzerListe) {
+    for (Benutzer benutzer : benutzerListe) {
+        benutzer.berechneJahresgebuehren();
+    }
+}
+Aufruf der Methode
+java
+Copy code
+BibliothekSystem bibliothekSystem = BibliothekSystem.getInstance();
+bibliothekSystem.berechneJahresgebuehrenFuerAlleBenutzer(benutzerListe);
+5. Aktualisierung des Gebührenkontos bei Aktionen
+Das System kann die Jahresgebühren im Gebührenkonto automatisch berücksichtigen, wenn der Benutzer sein Konto abruft:
+
+Aktualisierung bei Kontoabfrage
+java
+Copy code
+public double getGesamtgebuehren() {
+    return getGebuehrenkonto(); // Gebührensaldo inklusive Jahresgebühren
+}
+6. Ausgabe für den Benutzer
+Die Gebühren können bei jeder Benutzerinteraktion angezeigt werden, z. B. bei der Anmeldung:
+
+java
+Copy code
+System.out.println("Ihre Gesamtgebühren betragen: " + benutzer.getGesamtgebuehren() + "€");
+Zusammenfassung
+Die jährlichen Gebühren werden über die Methode getJahresgebuehren() aus den Unterklassen abgerufen.
+Die Methode berechneJahresgebuehren() fügt die Gebühren zum Konto des Benutzers hinzu.
+Entweder bei der Erstellung eines Benutzers oder zu einem bestimmten Zeitpunkt (z. B. Jahreswechsel) werden die Gebühren berechnet.
+Das Gebührenkonto wird automatisch aktualisiert und bei Benutzeraktionen angezeigt.
+Mit dieser Struktur bleibt das System flexibel und wartbar.

LibrarySystem/andereDateien/KIchatGPT/prompt7.txt

@@ -0,0 +1,41 @@
+ich: ändere die Klasse UI so, so dass du so viel wie möglich Lambda-Ausdrücke verwendest (Eingabe von Klasse UI)
+
+AI: hier ist die überarbeite Klasse UI, die Lambda-Ausdrücke enthält:
+
+public void starten() {
+        while (true) {
+            System.out.println("Willkommen in der Bibliothek!\n");
+            System.out.println("1. Anmelden");
+            System.out.println("2. Medien durchsuchen");
+            System.out.println("3. Ausleihen eines Mediums");
+            System.out.println("4. Rückgabe eines Mediums");
+            System.out.println("5. Zeige ausgeliehene Medien und Gebühren");
+            System.out.println("6. Verlängern der Leihfrist");
+            System.out.println("7. Admin-Login (Überfällige Gebühren verbuchen)");
+            System.out.println("8. Systemdatum manuell ändern.");
+            System.out.println("0. Beenden\n");
+            System.out.print("Bitte wählen Sie eine Option: ");
+            int auswahl = scanner.nextInt();
+            scanner.nextLine();
+
+            switch (auswahl) {
+                case 1 -> anmelden();
+                case 2 -> durchsuchenMedien();
+                case 3 -> ausleihenMedium();
+                case 4 -> rueckgabeMedium();
+                case 5 -> zeigeAusgelieheneMedienUndGebuehren();
+                case 6 -> verlaengernLeihfrist();
+                case 7 -> adminLogin();
+                case 8 -> aendernDatumManuell();
+                case 0 -> {
+                    System.out.println("Auf Wiedersehen!");
+                    return;
+                }
+                default -> System.out.println("Ungültige Auswahl, bitte erneut versuchen.");
+            }
+        }
+    }
+    .
+    .
+    .
+Die Methoden anmelden(), durchsuchenMedien(), usw. bleiben unverändert.

LibrarySystem/andereDateien/KIchatGPT/prompt8.txt

@@ -0,0 +1,14 @@
+ich: erstelle eine Methode, die der Medienkatalog nach Titel, medienart und ob es ausgeliehen ist durchsucht
+
+AI: Hier ist die Methode durchsuchenMedien(String titelTeil, String medienart, Boolean istAusgeliehen),
+die der Medienkatalog nach Titel, medienart und ob es ausgeliehen ist durchsucht
+
+Java Code:
+// Durchsuchen der Medien nach einem Titel (Teilstring) und Filterung nach Eigenschaften
+    public List<Medium> durchsuchenMedien(String titelTeil, String medienart, Boolean istAusgeliehen) {
+        return medien.stream()
+                .filter(m -> m.getTitel().toLowerCase().contains(titelTeil.toLowerCase()))  // Titel-Filter
+                .filter(m -> medienart == null || m.getMedienart().equalsIgnoreCase(medienart))  // Medienart-Filter
+                .filter(m -> istAusgeliehen == null || m.istAusgeliehen() == istAusgeliehen)  // Ausleihstatus-Filter
+                .collect(Collectors.toList());
+    }

LibrarySystem/andereDateien/notizen/vorgehen.txt

@@ -0,0 +1,60 @@
+Wie soll die Interaktion zwischen Benutzer und System aussehen?
+
+1. Benutzer darf nur mit der UI kommunizieren;
+2. Die UI darf nur das Bibliothekssystem (facade) sehen, vielleicht auch die Benutzer-Klasse, um sinnvoll eine Liste
+der Benutzerverwalten zu können.
+3. In der Domain sollen alle anderen Klassen sein, also Medium mit ihren Subklassen und Benutzer mit ihren Subklassen.
+4. Die Klasse Bibliothekssystem darf die Klassen der Domain sehen und auf diese zugreifen können -> das kann man mit
+'import' realisieren.
+
+Iterationen:
+
+1. Anmelden
+Benutzer wählt 1 für Anmelden in die UI -> System fragt nach Kartennummer -> Eingabe durch Benutzer -> bei einer richtige
+Eingabe (bzw. Benutzer befindet sich in die Benutzerliste) gilt der Benutzer als angemeldet und darf weiter machen
+
+2. Medien durchsuchen
+Benutzer wählt dafür 2 in der UI -> System fragt nach Titel und Medienart -> Eingabe durch Benutzer -> das System bildet
+ein Stream und durchsucht die Liste für Medien nach den passenden Kriterien -> bei einer richtige Eingabe durch den
+Benutzer wird das gesuchte Medium zurückgegeben mit ID, Titel, Autor, Erscheinungsjahr und Status der Ausleihe
+
+3. Ausleihe eines Mediums
+Benutzer wählt dafür 3 in der UI -> System fragt nach Kartennummer (für die Anmeldung) -> falls Benutzer existiert wird
+nach ID des Mediums gefragt bzw. Benutzer muss diese eingeben -> stimmen die beiden Nummern, so wird das Medium in der
+Liste mit Ausleihen des Benutzers hinzugefügt und das Rückgabedatum wird berechnet -> Benutzer bekommt die Benachrichtigung,
+ob die Ausleihe erfolgreich war, zusammen mit dem Rückgabedatum
+
+4. Rückgabe eines Mediums
+Benutzer wählt dafür 4 in der UI -> System fragt nur nach Medium ID (eine Eingabe der Kartennummer ist nicht notwendig) ->
+System sucht nach dem Medium mit der ergebenen Medium ID, und nennt der Benutzer erstmal nur Ausleiher, weiterhin unbekannt
+ist -> System setzt den Benutzer gleich dem Ausleiher, falls in der Liste der Benutzer einen Benutzer gibt, der dieses
+Medium in seiner Liste der Ausleihen drin hat -> Falls das richtig ist, entfernt das System das Medium aus der Liste der
+Ausleihen des Benutzers -> System macht dann mit der Berechnung der Gebühren weiter, falls das aktuelle Datum über das
+Rückgabedatum liegt (overdue) -> Benutzer bekommt die Ausgabe über die aktuelle Gebühren und eine Liste mit Ausleihen,
+die der Benutzer noch hat
+
+5. Zeige ausgeliehene Medien und Gebühren
+Benutzer wählt dafür 5 in der UI -> System fragt nach Kartennummer (für die Anmeldung) -> falls Benutzer existiert schaut
+das System nach seinen offenen Gebühren -> System gibt die offenen Gebühren, sowie die Liste mit der Ausleihen des
+Benutzers an
+
+6. Verlängern der Leihfrist
+Benutzer wählt dafür 6 in der UI -> System fragt nach Kartennummer (für die Anmeldung) und Medium ID für das Medium,
+das verlängert sein sollte -> Eingabe durch den Benutzer -> Falls Benutzer existiert und Medium ist von ihm ausgeliehen,
+schaut das System, ob dieses Medium überhaupt verlängerbar ist -> falls ja, so werden die Verlängerungen um 1 niedriger
+und das Rückgabedatum wird zurückgesetzt -> Benutzer bekommt die Ausgabe mit der neuen Leihfrist und wie viele weitere
+Verlängerungen möglich sind für dieses eine Medium
+
+7. Admin-Login (Überfällige Gebühren verbuchen)
+Benutzer wählt dafür 7 in der UI -> System fragt nach Kartennummer (für die Anmeldung) -> falls die Kartennummer eine A
+am Anfang hat, meldet das System den Benutzer als Admin an -> wenn das erfolgreich war, gibt der Admin die Kartennummer
+des Benutzers an, der seine Gebühren bezahlen will -> falls die Kartennummer richtig ist und der Benutzer hat offenen
+Gebühren, so werden diese passend von Benutzer bezahlt -> Admin setzt das Gebührenkonto auf 0 zurück und der Benutzer
+hat keine offene Gebühren mehr
+
+8.Systemdatum manuell ändern (zum Testzwecken)
+Benutzer wählt dafür 8 in der UI -> Benutzer gibt das gewünschte Datum in YYYY-MM-DD an -> System ändert das aktuelle
+Datum des Systems auf das neu eingebene Datum, womit er ab diesen Punkt weiter macht
+
+0. Beenden
+Benutzer wählt dafür 8 in der UI -> Programm wird beendet

LibrarySystem/domain/benutzern/Admin.java

@@ -0,0 +1,34 @@
+package LibrarySystem.domain.benutzern;
+
+
+import LibrarySystem.domain.medien.Medium;
+
+public class Admin extends Benutzer {
+
+     public Admin(String kartennummer, String name, int alter) {
+         super(kartennummer,name, alter, "A");
+     }
+
+     @Override
+     public double getJahresgebuehr() {
+         return 0;
+     }
+
+     // Admin-spezifische Methoden: Benutzerübersicht anzeigen
+     public void anzeigenBenutzer(Benutzer[] benutzerListe) {
+         System.out.println("\nBenutzerübersicht:");
+         for (Benutzer b : benutzerListe) {
+             System.out.println(b);
+         }
+     }
+
+     public void bestaetigeGebuehrenzahlung(Benutzer benutzer) {
+         if(benutzer.getOffeneGebuehren() > 0) {
+             benutzer.bezahleGebuehren();
+             System.out.println("Gebühren von " + benutzer.getName() + " wurden erfolgreich bezahlt.");
+         } else {
+             System.out.println("Keine offene Gebühren für " + benutzer.getName() + ".") ;
+         }
+     }
+}
+

LibrarySystem/domain/benutzern/Benutzer.java

@@ -0,0 +1,95 @@
+package LibrarySystem.domain.benutzern;
+
+import LibrarySystem.domain.medien.*;
+
+import java.util.*;
+
+public abstract class Benutzer {
+    private String kartennummer;
+    private String name;
+    private int alter;
+    private List<Medium> ausleihen;
+    private double offeneGebuehren;
+
+    Benutzer(String kartennummer, String name, int alter, String prefix) {
+        this.kartennummer = prefix + kartennummer;
+        this.name = name;
+        this.alter = alter;
+        this.ausleihen = new ArrayList<>();
+        this.offeneGebuehren = 0.0;
+    }
+
+    //Getter und Setter
+    public String getKartennummer() {return kartennummer;}
+    public void setKartennummer(String kartennummer) {this.kartennummer = kartennummer;}
+    public String getName() {return name;}
+    public void setName(String name) {this.name = name;}
+    public int getAlter() {return alter;}
+    public void setAlter(int alter) {this.alter = alter;}
+    public List<Medium> getAusleihen() {return ausleihen;}
+    public double getOffeneGebuehren() {return offeneGebuehren;}
+
+
+    // Abstrakte Methode für die Jahresgebühr
+    public abstract double getJahresgebuehr();
+
+    //Methode fürs Ausleihen
+    public void ausleihen(Medium medium) {
+        if(!medium.istAusgeliehen()){
+            ausleihen.add(medium);
+            medium.ausleihen();
+            //System.out.println(name +  " hat \"" + medium.getTitel() + "\" ausgeliehen. Rückgabefrist: " + medium.getRueckgabedatum());
+        } else{
+            System.out.println("Das Medium ist bereits ausgeliehen.");
+        }
+    }
+
+    //Methode für die Rückgabe
+    public void rueckgabe(Medium medium) {
+        if(ausleihen.contains(medium)){
+            ausleihen.remove(medium);
+            medium.rueckgabeMedium();
+        }
+        else{
+            System.out.println("Dieses Medium von diesem Benutzer nicht ausgeliehen.");
+        }
+    }
+
+
+    //Methode zum Anzeigen der Ausleihen eines Benutzers
+    public void anzeigenAusleihen() {
+        if(ausleihen.isEmpty()){
+            System.out.println("Keine ausgeliehenen Medien.");
+        }else {
+            System.out.println("Aktuell ausgeliehene Medien von " + name + ":\n");
+            for (Medium medium : ausleihen) {
+                System.out.println("- " + medium.getTitel() + " (Fällig am: " + medium.getRueckgabedatum() + ")\n");
+            }
+        }
+    }
+
+    //Methode zum Addieren der Gebühren zu den offenen Gebühren
+    public void addiereZuOffeneGebuehren(double gebuehren){
+        this.offeneGebuehren+= gebuehren;
+    }
+
+    //Methode für den Admin, um nach eine erfolgreiche Bezahlung das Konto auf 0 zu setzen
+    public void bezahleGebuehren() {
+        offeneGebuehren = 0.0;
+    }
+
+
+
+     /*public void aktualisiereGebuehren(Date aktuellesDatum) {
+        if (gebuehrenBezahlt) return; // Keine Aktualisierung erforderlich, wenn bezahlt
+        offeneGebuehren = 0.0;
+        for (Medium ausleihe : ausleihen) {
+            offeneGebuehren += ausleihe.berechneGebuehren(aktuellesDatum);
+        }
+    }*/
+
+    @Override
+    public String toString() {
+        return "Name: " + name +  ", Alter: " + alter + ", Kartennummer: " + kartennummer;
+    }
+}

LibrarySystem/domain/benutzern/Erwachsener.java

@@ -0,0 +1,15 @@
+package LibrarySystem.domain.benutzern;
+
+ public class Erwachsener extends Benutzer {
+
+    private static final double JAHRESGEBUEHR = 50.0;
+
+    public Erwachsener(String kartennummer,String name, int alter) {
+        super(kartennummer, name, alter, "E");
+    }
+
+     @Override
+    public double getJahresgebuehr() {
+        return JAHRESGEBUEHR;
+    }
+}

LibrarySystem/domain/benutzern/Student.java

@@ -0,0 +1,15 @@
+package LibrarySystem.domain.benutzern;
+
+ public class Student extends Benutzer {
+
+    private static final double JAHRESGEBUEHR_ERMAESSIGT = 25.0;
+
+    public Student(String kartennummer, String name, int alter) {
+        super(kartennummer, name, alter, "S");
+    }
+
+    @Override
+    public double getJahresgebuehr() {
+        return JAHRESGEBUEHR_ERMAESSIGT;
+    }
+}

LibrarySystem/domain/medien/Ausleihbar.java

@@ -0,0 +1,7 @@
+package LibrarySystem.domain.medien;
+
+public interface Ausleihbar {
+    void ausleihen();
+    void rueckgabeMedium();
+    boolean istOverdue();
+}

LibrarySystem/domain/medien/Brettspiel.java

@@ -0,0 +1,22 @@
+package LibrarySystem.domain.medien;
+
+
+public class Brettspiel extends Medium {
+    private static final int AUSLEIHDAUER = 14; // 2 Wochen
+
+    public Brettspiel(String ID, String titel, String autor, int erscheinungsjahr, String medienart, int verlaengerungen) {
+        super(ID, titel, autor, erscheinungsjahr, medienart, verlaengerungen);
+    }
+
+
+    @Override
+    public int getAusleihdauer() {
+        return AUSLEIHDAUER;
+    }
+
+    @Override
+    public boolean istVerlaengerbar() {
+        return false; //Keine Verlängerung
+    }
+
+}

LibrarySystem/domain/medien/Buch.java

@@ -0,0 +1,23 @@
+package LibrarySystem.domain.medien;
+
+
+public class Buch extends Medium {
+    private static final int AUSLEIHDAUER = 28; //4 Wochen in Tagen
+    //private int verlaengerungenBuch = 3;
+
+     public Buch(String ID, String titel, String autor, int erscheinungsjahr, String medienart, int verlaengerungen) {
+         super(ID, titel, autor, erscheinungsjahr, medienart, verlaengerungen);
+     }
+
+
+    @Override
+    public int getAusleihdauer() {
+        return AUSLEIHDAUER;
+    }
+
+    @Override
+    public boolean istVerlaengerbar() {
+        return verlaengerungen >0;
+    }
+
+}

LibrarySystem/domain/medien/CD.java

@@ -0,0 +1,21 @@
+package LibrarySystem.domain.medien;
+
+public class CD extends Medium {
+    public static final int AUSLEIHDAUER = 14; // 2 Wochen
+
+    public CD(String ID, String titel, String autor, int erscheinungsjahr, String medienart, int verlaengerungen) {
+        super(ID, titel, autor, erscheinungsjahr, medienart, verlaengerungen);
+    }
+
+
+    @Override
+    public int getAusleihdauer() {
+        return AUSLEIHDAUER;
+    }
+
+    @Override
+    public boolean istVerlaengerbar() {
+        return false;
+    }
+
+}

LibrarySystem/domain/medien/DVD.java

@@ -0,0 +1,28 @@
+package LibrarySystem.domain.medien;
+
+public class DVD extends Medium {
+    private static final int AUSLEIHDAUER = 7; // 1 Woche
+
+    public DVD(String ID, String titel, String autor, int erscheinungsjahr, String medienart, int verlaengerungen) {
+        super(ID, titel, autor, erscheinungsjahr, medienart, verlaengerungen);
+    }
+
+
+    @Override
+    public int getAusleihdauer() {
+        return AUSLEIHDAUER;
+    }
+
+    @Override
+    public boolean istVerlaengerbar() {
+        return false; //Keine Verlängerung
+    }
+
+    /*@Override
+    public int verlaengern() {
+        System.out.println("DVDs können nicht verlängert werden.");
+        return 0;
+    }*/
+
+
+}

LibrarySystem/domain/medien/Medium.java

@@ -0,0 +1,102 @@
+package LibrarySystem.domain.medien;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.Calendar;
+import java.util.Date;
+
+public abstract class Medium implements Ausleihbar{
+    private String ID;
+    private String titel;
+    private String autor;
+    private int erscheinungsjahr;
+    private String medienart;
+    private boolean ausgeliehen;
+    private Date rueckgabedatum;
+    public int verlaengerungen;
+
+    public Medium(String ID, String titel, String autor, int erscheinungsjahr, String medienart, int verlaengerungen) {
+        this.ID = ID;
+        this.titel = titel;
+        this.autor = autor;
+        this.erscheinungsjahr = erscheinungsjahr;
+        this.medienart = medienart;
+        this.ausgeliehen = false;
+        this.verlaengerungen =verlaengerungen;
+    }
+
+
+     //Getter und Setter
+     public String getID() {
+         return ID;
+     }
+     public void setID(String ID) {
+         this.ID = ID;
+     }
+     public String getTitel() {
+         return titel;
+     }
+     public void setTitel(String titel) {
+         this.titel = titel;
+     }
+     public String getAutor() {
+         return autor;
+     }
+     public void setAutor(String autor) {
+         this.autor = autor;
+     }
+     public int getErscheinungsjahr() {
+         return erscheinungsjahr;
+     }
+     public void setErscheinungsjahr(int erscheinungsjahr) {
+         this.erscheinungsjahr = erscheinungsjahr;
+     }
+     public String getMedienart() {return medienart;}
+     public void setMedienart(String Medienart) {this.medienart = Medienart;}
+     public boolean istAusgeliehen() {return ausgeliehen;}
+     public void setAusgeliehen() {this.ausgeliehen = true;}
+     public void setRueckgabe(){this.ausgeliehen = false;}
+     public Date getRueckgabedatum(){return rueckgabedatum;}
+     public void setRueckgabedatum(Date rueckgabedatum){this.rueckgabedatum = rueckgabedatum;}
+     public int getVerlaengerungen() {return verlaengerungen;}
+     public void setVerlaengerungen(int verlaengerungen) {}
+
+    //Andere nützliche Methoden
+    public Date rechneRueckgabedatum(Date systemDatum){
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(systemDatum);
+        calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer());
+        this.rueckgabedatum = calendar.getTime();
+        return rueckgabedatum;
+    }
+
+    //Abstrakte Methoden
+    public abstract int getAusleihdauer();
+    public abstract boolean istVerlaengerbar();
+
+    @Override
+    public void ausleihen() {
+        if(!istAusgeliehen()){
+            setAusgeliehen();
+        } else{
+            System.out.println("Medium ist bereits ausgeliehen.");
+        }
+    }
+
+    @Override
+    public void rueckgabeMedium() {
+        setRueckgabe();
+    }
+
+    @Override
+    public boolean istOverdue() {
+        return new Date().after(getRueckgabedatum());
+    }
+
+
+    @Override
+     public String toString() {
+        return "ID: " + ID + ", Titel: " + titel + ", Autor: " + autor + ", Erscheinungsjahr: " + erscheinungsjahr + ", Ausgeliehen: " + ausgeliehen;
+     }
+
+}

LibrarySystem/domain/medien/Videospiel.java

@@ -0,0 +1,32 @@
+package LibrarySystem.domain.medien;
+
+public class Videospiel extends Medium {
+    private static final int AUSLEIHDAUER = 28; // 4 Wochen
+
+    public Videospiel(String ID, String titel, String autor, int erscheinungsjahr, String medienart, int verlaengerungen) {
+        super(ID, titel, autor, erscheinungsjahr, medienart, verlaengerungen);
+    }
+
+
+    @Override
+    public int getAusleihdauer() {
+        return AUSLEIHDAUER;
+    }
+
+    @Override
+    public boolean istVerlaengerbar() {
+        return verlaengerungen>0;
+    }
+
+    /*@Override
+    public int verlaengern() {
+        if (istVerlaengerbar()){
+            verlaengerungen--;
+            //rechneRueckgabedatum(); //Verlängerung
+        } else {
+            System.out.println("Keine Verlängerung mehr möglich");
+        }
+        return verlaengerungen;
+    }*/
+
+}

LibrarySystem/facade/BibliothekSystem.java

@@ -0,0 +1,256 @@
+package LibrarySystem.facade;
+
+//Imports aus domain
+import LibrarySystem.domain.benutzern.*;
+import LibrarySystem.domain.medien.*;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BibliothekSystem {
+    private List<Benutzer> benutzerListe;
+    private Date aktuellesDatum; //Standardmäßig aktuelles Datum
+    private List<Medium> medienListe;
+
+    public BibliothekSystem() {
+        this.benutzerListe = new ArrayList<>();
+        this.aktuellesDatum = new Date();
+        this.medienListe = new ArrayList<>();
+        initialMedienHinzufuegen();
+        initialBenutzerHinzufuegen();
+    }
+
+    // Methode zum Hinzufügen von Medien
+    private void initialMedienHinzufuegen() {
+        // Beispiel-Medien hinzufügen
+        Buch buch1 = new Buch("123","Java lernen", "Max Mustermann", 2020, "Buch", 3);
+        Buch buch2 = new Buch("234","Java für Einsteiger", "Erika Musterfrau", 2014, "Buch", 3);
+        Buch buch3 = new Buch("2345","Java für Einsteiger", "Erika Musterfrau", 2014, "Buch", 3);
+        DVD dvd1 = new DVD("345","Die Matrix", "Lana Wachowski", 2014, "DVD", 0);
+        DVD dvd2 = new DVD("543","Die Matrix", "Lana Wachowski", 2014, "DVD", 0);
+        CD cd1 = new CD("456","Best of Mozart", "-", 1850, "CD", 0);
+        CD cd2 = new CD("654","Christmas Carols", "-", 2000, "CD", 0);
+        Brettspiel brettspiel1 = new Brettspiel("567","Monopoly", "-",2010, "Brettspiel", 0);
+        Brettspiel brettspiel2 = new Brettspiel("765","Siedler von Catan", "-",2014, "Brettspiel", 0);
+        Videospiel videospiel1 = new Videospiel("678","Minecraft", "-", 2011, "Videospiel", 1);
+        Videospiel videospiel2 = new Videospiel("876","Call of Duty", "-", 2017, "Videospiel",1);
+
+        // Medien zur Bibliothek hinzufügen
+        addMedium(buch1);
+        addMedium(buch2);
+        addMedium(buch3);
+        addMedium(dvd1);
+        addMedium(dvd2);
+        addMedium(cd1);
+        addMedium(cd2);
+        addMedium(brettspiel1);
+        addMedium(brettspiel2);
+        addMedium(videospiel1);
+        addMedium(videospiel2);
+    }
+
+    //Methode zum Hinzufügen von Medien in die Medienliste
+    public void addMedium(Medium medium) {
+        medienListe.add(medium);
+    }
+
+    // Methode zum Hinzufügen von Benutzern und Admin
+    private void initialBenutzerHinzufuegen(){
+    Benutzer student = new Student("1234567", "Ana Misk", 21);
+    Benutzer erwachsener = new Erwachsener("2345678","Paul Mark", 34);
+    Admin admin = new Admin("3456789", "Alisa Admin", 40);
+        benutzerRegistrieren(student);
+        benutzerRegistrieren(erwachsener);
+        benutzerRegistrieren(admin);
+    }
+
+    //Methode zum Anmelden eines Benutzers
+    public Benutzer anmelden(String kartennummer) {
+        for (Benutzer benutzer : benutzerListe) {
+            if (benutzer.getKartennummer().equals(kartennummer)) {
+                return benutzer;
+            }
+        }
+        System.out.println("Benutzer nicht gefunden.");
+        return null;
+    }
+
+    // Durchsuchen der Medien nach einem Titel (Teilstring) und Filterung nach Eigenschaften
+    //Von AI generiert
+    public void durchsuchenMedien(String titelTeil, String medienart) {
+        List medienliste = medienListe.stream()
+                .filter(m -> m.getTitel().toLowerCase().contains(titelTeil.toLowerCase()))  // Titel-Filter
+                .filter(m -> medienart == null || m.getMedienart().equalsIgnoreCase(medienart))  // Medienart-Filter
+                //.filter(m -> ausgeliehen == null || m.istAusgeliehen() == istAusgeliehen)  // Ausleihstatus-Filter
+                .collect(Collectors.toList());
+
+        if(medienliste.isEmpty()) {
+            System.out.println("Keine passende Medien gefunden.");
+        } else {
+            System.out.println(medienliste);
+        }
+
+    }
+
+    // Methode zum Ausleihen eines Mediums
+    public void ausleiheMedium(String kartennummer, String mediumID){
+        Benutzer benutzer = anmelden(kartennummer);
+        Medium medium = findeMedium(mediumID);
+        if (benutzer != null && medium != null && !medium.istAusgeliehen()) {
+            benutzer.ausleihen(medium);
+            medium.setRueckgabedatum(medium.rechneRueckgabedatum(aktuellesDatum));
+            System.out.println(benutzer.getName() + " hat " + medium.getTitel() + " ausgeliehen.");
+            System.out.println("Rückgabedatum: " + medium.getRueckgabedatum());
+            System.out.println("Verlängerungen möglich insgesamt: " + medium.getVerlaengerungen());
+        } else {
+            System.out.println("Ausleihe nicht möglich.");
+        }
+    }
+
+    //Methode zum Rückgeben eines Mediums
+    public void rueckgabeMedium(String mediumID){
+        Medium medium = findeMedium(mediumID);
+        Benutzer ausleiher = null;
+        if(medium == null) {
+            System.out.println("Medium mit der ID " + mediumID + " nicht gefunden.");
+            return;
+        }
+        if(!medium.istAusgeliehen()) {
+            System.out.println("Medium '"+medium.getTitel()+"' ist nicht ausgeliehen.");
+            return;
+        }
+
+        // Benutzer finden, der das Medium ausgeliehen hat
+        for(Benutzer benutzer : benutzerListe) {
+            if(benutzer.getAusleihen().contains(medium)){
+                ausleiher = benutzer;
+                break;
+            }
+        }
+
+        if(ausleiher == null) {
+            System.out.println("Kein Benutzer gefunden, der dieses Medium ausgeliehen hat.");
+            return;
+        }
+        //Medium zurückgeben
+        ausleiher.rueckgabe(medium);
+        System.out.println("Medium '"+medium.getTitel()+"' wurde erfolgreich am " + getAktuellesDatum() + " zurückgegeben.");
+
+
+        //Für die Angabe des Gebührenkontos
+        //Von AI teilweise generiert
+            if(aktuellesDatum.after(medium.getRueckgabedatum())){
+                long overdueTage = (aktuellesDatum.getTime() - medium.getRueckgabedatum().getTime()) / (1000 * 60 * 60 * 24);
+                System.out.println("überfällige Tagen: " + overdueTage);
+                double gebuehr = rechneOverdueGebuehren(overdueTage);
+                ausleiher.addiereZuOffeneGebuehren(gebuehr);
+                System.out.println("Medium '" + medium.getTitel() + "' wurde erfolgreich zurückgegeben.");
+                System.out.println("Überfällige Gebühren für " + ausleiher.getName() + ": " + gebuehr + " Eur.");
+            }else {
+                System.out.println("Medium '" + medium.getTitel()+ "' wurde rechtzeitig zurückgegeben");
+            }
+
+        System.out.println("Verbleibende ausgeliehene Medien von " + ausleiher.getName() + ":");
+            ausleiher.anzeigenAusleihen();
+
+    }
+
+    //Methode zum Anzeigen des Gebührenkontos
+    public void zeigeGebuehrenkonto(String kartennummer){
+        Benutzer benutzer = anmelden(kartennummer);
+        if (benutzer == null) {
+            System.out.println("Kein Benutzer gefunden.");
+            return;
+        }
+
+        double gebuehren = benutzer.getOffeneGebuehren();
+        if (gebuehren>0){
+            System.out.println("Offene Gebühren für " + benutzer.getName() + ": " + gebuehren + " Eur.");
+        } else {
+            System.out.println("Keine offene Gebühren für "+ benutzer.getName() + ".");
+        }
+
+    }
+
+    //Methode zum Verlängern eines Mediums
+    public void verlaengernMedium(String kartennummer,String mediumID){
+        Benutzer benutzer = anmelden(kartennummer);
+        Medium medium = findeMedium(mediumID);
+        if (benutzer != null && medium != null && medium.istAusgeliehen()) {
+            if (medium.istVerlaengerbar()) {
+                if (medium.istVerlaengerbar()) {
+                    medium.verlaengerungen--;
+                    //setAktuellesDatum(aktuellesDatum); //hier Änderung gemacht, wohin stand setzeAktuellesDatumZurueck
+                    setzeAktuellesDatumZurueck();
+                    medium.setRueckgabedatum(medium.rechneRueckgabedatum(aktuellesDatum));
+                } else{
+                    System.out.println("Keine Verlängerung mehr möglich.");
+                }
+                System.out.println("Leihfrist für '" + medium.getTitel() + "' verlängert.");
+                System.out.println("Neues Rückgabedatum: " + medium.getRueckgabedatum());
+                System.out.println("Weitere Verlängerungen möglich: " + medium.getVerlaengerungen());
+            } else{
+                    System.out.println("Verlängerung nicht möglich. Bitte geben Sie das Medium an dem Rückgabedatum zurück!");
+                }
+
+        } else {
+            System.out.println("Verlängerung nicht möglich, da Kartennummer falsch ist oder Medium existiert nicht.");
+        }
+    }
+
+
+    //Methode zum Berechnen der overdue-Gebühren
+    //Von AI generiert
+    public double rechneOverdueGebuehren(long overdueTagen) {
+        if (overdueTagen <= 0){
+            return 0;
+        }
+        if (overdueTagen <= 7){
+            return overdueTagen * 1.0; //1 euro pro Tag für die ersten 7 Tage
+        }
+        return (7*1.0) + ((overdueTagen - 7) * 2.0); // 2 euro pro Tag ab dem 8. Tag
+    }
+
+
+    //------------Hilfsmethoden-----------------------
+
+
+    //Methode zum Finden eines Benutzers
+    public Benutzer findeBenutzer(String kartennummer) {
+        return benutzerListe.get(Integer.parseInt(kartennummer));
+    }
+
+    //Methode zum Finden eines Mediums
+    //Von AI generiert
+    public Medium findeMedium(String ID) {
+        return medienListe.stream()
+                .filter(m -> m.getID().equals(ID))
+                .findFirst()
+                .orElse(null);
+    }
+
+    //Methode, um das Systemdatum zu setzen
+    public void setAktuellesDatum(Date manuellesDatum) {
+        this.aktuellesDatum = manuellesDatum;
+        System.out.println("Systemdatum geändert auf: " + aktuellesDatum);
+    }
+
+    public Date getAktuellesDatum() {
+        return aktuellesDatum;
+    }
+
+    public void setzeAktuellesDatumZurueck(){
+        this.aktuellesDatum = new Date();
+    }
+
+    public void benutzerRegistrieren(Benutzer benutzer) {
+        benutzerListe.add(benutzer);
+        double jahresgebuehr = benutzer.getJahresgebuehr();
+        System.out.println("Benutzer registriert: " + benutzer + ", Jahresgebühr: " + jahresgebuehr);
+    }
+
+
+
+}