Compare commits
No commits in common. "main" and "Feature-Admin" have entirely different histories.
main
...
Feature-Ad
|
|
@ -1,57 +0,0 @@
|
|||
User: erkläre mir wie ich in der Methode returnMedium die Gebühren ausrechnen kann
|
||||
|
||||
|
||||
|
||||
System: 1. Zugrunde liegende Logik:
|
||||
Wenn das Medium pünktlich oder vor dem Fälligkeitsdatum zurückgegeben wird:
|
||||
Keine Gebühren fallen an.
|
||||
Wenn das Medium nach dem Fälligkeitsdatum zurückgegeben wird:
|
||||
1€ pro Tag für die ersten 7 überfälligen Tage.
|
||||
2€ pro Tag für alle weiteren Tage.
|
||||
2. Schritte zur Gebührenberechnung:
|
||||
a) Überprüfen, ob das Medium überfällig ist:
|
||||
|
||||
Überprüfe, ob das aktuelle Datum (currentDate) nach dem Fälligkeitsdatum (dueDate) liegt:
|
||||
if (currentDate.isAfter(dueDate)) {
|
||||
// Das Medium ist überfällig
|
||||
}
|
||||
b) Überfällige Tage berechnen:
|
||||
|
||||
Berechne die Anzahl der Tage, die das Medium überfällig ist:
|
||||
long overdueDays = ChronoUnit.DAYS.between(dueDate, currentDate);
|
||||
c) Gebührenberechnung basierend auf den überfälligen Tagen:
|
||||
|
||||
Verwende eine Bedingung, um zwischen den ersten 7 Tagen und den weiteren Tagen zu unterscheiden:
|
||||
double fee;
|
||||
if (overdueDays > 7) {
|
||||
fee = 7 * 1 + (overdueDays - 7) * 2; // 1€ für die ersten 7 Tage, 2€ für die restlichen Tage
|
||||
} else {
|
||||
fee = overdueDays * 1; // 1€ pro Tag für die ersten 7 Tage
|
||||
}
|
||||
d) Gebühren zum Benutzerkonto hinzufügen:
|
||||
|
||||
Addiere die berechneten Gebühren zu den ausstehenden Gebühren des Benutzers:
|
||||
user.addFee(fee);
|
||||
|
||||
5. Beispielberechnung:
|
||||
Beispiel 1:
|
||||
|
||||
Fälligkeitsdatum: 2024-12-01
|
||||
Rückgabedatum: 2024-12-05
|
||||
Überfällige Tage: 4
|
||||
Gebühren: 4€ (1€ pro Tag für 4 Tage)
|
||||
Beispiel 2:
|
||||
|
||||
Fälligkeitsdatum: 2024-12-01
|
||||
Rückgabedatum: 2024-12-10
|
||||
Überfällige Tage: 9
|
||||
Gebühren:
|
||||
7€ (1€ für die ersten 7 Tage) + 4€ (2€ für die verbleibenden 2 Tage) = 11€
|
||||
Vorteile:
|
||||
Klar definierte Regeln:
|
||||
Gebührenberechnung erfolgt strikt nach den Vorgaben.
|
||||
Flexibilität:
|
||||
Die Logik kann leicht angepasst werden, falls sich die Gebührenregeln ändern.
|
||||
Nachvollziehbarkeit:
|
||||
Die Berechnung der Gebühren ist für den Benutzer transparent, da die Anzahl der überfälligen Tage und die Gebühren angezeigt werden.
|
||||
Falls du noch weitere Anpassungen benötigst, lass es mich wissen! 😊
|
||||
|
|
@ -1,130 +0,0 @@
|
|||
User: wie kann ich speziell nach einer Medienart filtern? am besten mit lamba ausdrücken
|
||||
|
||||
|
||||
System: m in Java mit Lambda-Ausdrücken nach einer spezifischen Medienart zu filtern, kannst du den Stream und die filter()-Methode verwenden. Dabei kannst du die getClass()-Methode und getSimpleName() nutzen, um die Medienart zu bestimmen. Hier ein Beispiel, wie du speziell nach einer Medienart (z. B. Book, DVD, VideoGame) filtern kannst:
|
||||
|
||||
Beispiel für das Filtern nach Medienart:
|
||||
Angenommen, du hast eine Liste von Medien (mediaList), die unterschiedliche Typen von Medien enthalten (Bücher, DVDs, etc.), und du möchtest nur Medien eines bestimmten Typs herausfiltern.
|
||||
|
||||
1. Verwendung von Lambda-Ausdrücken:
|
||||
|
||||
Wenn du nach einer spezifischen Medienart filtern möchtest, kannst du die filter()-Methode des Streams zusammen mit getClass().getSimpleName() verwenden, um den Medientyp zu prüfen.
|
||||
|
||||
Codebeispiel:
|
||||
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class LibraryService {
|
||||
|
||||
private List<Medium> mediaList;
|
||||
|
||||
public LibraryService(List<Medium> mediaList) {
|
||||
this.mediaList = mediaList;
|
||||
}
|
||||
|
||||
public List<Medium> filterByMediaType(String mediaType) {
|
||||
return mediaList.stream()
|
||||
// Filter nach der Medienart (z. B. Book, DVD, etc.)
|
||||
.filter(medium -> medium.getClass().getSimpleName().equalsIgnoreCase(mediaType))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
// Beispiel-Initialisierung der Medien
|
||||
List<Medium> mediaList = List.of(
|
||||
new Book("B001", "Harry Potter", "J.K. Rowling"),
|
||||
new DVD("D001", "Inception"),
|
||||
new VideoGame("VG001", "The Last of Us")
|
||||
);
|
||||
|
||||
LibraryService libraryService = new LibraryService(mediaList);
|
||||
|
||||
// Filtern nach Buch
|
||||
List<Medium> books = libraryService.filterByMediaType("Book");
|
||||
books.forEach(medium -> System.out.println(medium.getTitle())); // Gibt "Harry Potter" aus
|
||||
|
||||
// Filtern nach DVD
|
||||
List<Medium> dvds = libraryService.filterByMediaType("DVD");
|
||||
dvds.forEach(medium -> System.out.println(medium.getTitle())); // Gibt "Inception" aus
|
||||
}
|
||||
}
|
||||
Erklärung des Codes:
|
||||
filter()-Methode:
|
||||
medium.getClass().getSimpleName(): Gibt den einfachen Namen der Klasse des Objekts zurück, z. B. "Book", "DVD", "VideoGame".
|
||||
equalsIgnoreCase(mediaType): Vergleicht den Klassennamen (Medienart) mit dem angegebenen mediaType (z. B. "Book"), wobei die Groß- und Kleinschreibung ignoriert wird.
|
||||
Lambda-Ausdruck: Der Filter gibt nur die Medien zurück, deren Klassennamen mit der angegebenen mediaType übereinstimmen.
|
||||
collect(Collectors.toList()):
|
||||
Nach der Filterung wird eine neue Liste mit den gefilterten Medien erstellt.
|
||||
Beispiel für verschiedene Medienarten:
|
||||
Angenommen, du möchtest nach verschiedenen Medienarten filtern und hast die folgenden Klassen:
|
||||
|
||||
abstract class Medium {
|
||||
private String id;
|
||||
private String title;
|
||||
|
||||
public Medium(String id, String title) {
|
||||
this.id = id;
|
||||
this.title = title;
|
||||
}
|
||||
|
||||
public String getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public String getTitle() {
|
||||
return title;
|
||||
}
|
||||
}
|
||||
|
||||
class Book extends Medium {
|
||||
private String author;
|
||||
|
||||
public Book(String id, String title, String author) {
|
||||
super(id, title);
|
||||
this.author = author;
|
||||
}
|
||||
|
||||
public String getAuthor() {
|
||||
return author;
|
||||
}
|
||||
}
|
||||
|
||||
class DVD extends Medium {
|
||||
public DVD(String id, String title) {
|
||||
super(id, title);
|
||||
}
|
||||
}
|
||||
|
||||
class VideoGame extends Medium {
|
||||
public VideoGame(String id, String title) {
|
||||
super(id, title);
|
||||
}
|
||||
}
|
||||
Filtern nach Book:
|
||||
// Filtern nach Büchern
|
||||
List<Medium> books = libraryService.filterByMediaType("Book");
|
||||
In diesem Beispiel werden nur Book-Objekte aus der mediaList zurückgegeben.
|
||||
Filtern nach DVD:
|
||||
// Filtern nach DVDs
|
||||
List<Medium> dvds = libraryService.filterByMediaType("DVD");
|
||||
In diesem Fall werden nur DVD-Objekte aus der mediaList zurückgegeben.
|
||||
Weitere Anpassungen:
|
||||
Dynamische Filterung: Du kannst die Medienarten als Parameter übergeben, z. B. durch eine Benutzereingabe.
|
||||
Mehrere Filter kombinieren: Wenn du mehrere Filterkriterien kombinieren möchtest, kannst du mehrere filter()-Methoden nacheinander aufrufen.
|
||||
Zusammenfassung:
|
||||
getClass().getSimpleName(): Gibt den Namen der Klasse (Medienart) zurück, z. B. Book, DVD, VideoGame.
|
||||
filter(): Wendet einen Filter auf den Stream an, um nur Objekte zu behalten, deren Medienart mit dem angegebenen mediaType übereinstimmt.
|
||||
equalsIgnoreCase(): Stellt sicher, dass die Medienart unabhängig von der Groß- oder Kleinschreibung verglichen wird.
|
||||
Durch die Verwendung von Lambda-Ausdrücken und Streams kannst du sehr einfach und flexibel nach einer spezifischen Medienart filtern.
|
||||
|
||||
Lass mich wissen, falls du weitere Fragen hast oder noch andere Anpassungen benötigst! 😊
|
||||
|
||||
|
||||
2/2
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue