Administrationsoberfläche

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy. Lektion 81 von 87.

Aufgabe

Einfach

Erweitern wir dein Bibliotheksverwaltungssystem um eine Admin-Oberfläche! Eine echte Bibliothek benötigt administrative Funktionen: neue Bücher zur Sammlung hinzufügen, veraltete Bücher entfernen und neue Mitglieder registrieren. Du erstellst ein Interface, das diese administrativen Operationen definiert, und implementierst sie in einer speziellen Admin-Klasse.

Du baust deinen bestehenden Code weiterhin über fünf Dateien hinweg aus:

Book.java: Behalte deine Book-Klasse mit allen vorhandenen Funktionen: isbn, title, author, isAvailable, borrowedBy, getDetails() sowie den entsprechenden Gettern/Settern.
User.java: Behalte deine User-Klasse unverändert mit id, name, der borrowedBooks ArrayList, borrowBook(), returnBook(), getBorrowedCount() und toString().
Library.java: Behalte deine Library-Klasse mit allen vorhandenen Methoden. Füge eine neue Methode removeBook(String isbn) hinzu, die ein Buch anhand seiner ISBN in der Sammlung findet und entfernt. Die Methode soll true zurückgeben, wenn das Buch gefunden und entfernt wurde, andernfalls false. Ein Buch kann nur entfernt werden, wenn es derzeit verfügbar ist (nicht ausgeliehen).
LibraryAdmin.java: Erstelle ein Interface namens LibraryAdmin, das den Vertrag für administrative Operationen definiert. Dein Interface sollte drei Methoden deklarieren:
- addBook(String isbn, String title, String author) – gibt einen Boolean zurück, der den Erfolg angibt
- removeBook(String isbn) – gibt einen Boolean zurück, der den Erfolg angibt
- registerUser(String id, String name) – gibt einen Boolean zurück, der den Erfolg angibt
Erstelle anschließend eine Klasse namens AdminService, die dieses Interface implementiert. Der AdminService sollte eine Referenz auf eine Library speichern (die über seinen Konstruktor übergeben wird) und alle drei Methoden implementieren, indem er sie an die Library delegiert und entsprechendes Feedback hinzufügt. Beim Hinzufügen eines Buches soll ein neues Book erstellt und zur Bibliothek hinzugefügt werden. Beim Registrieren eines Benutzers soll ein neuer User erstellt und registriert werden.
Main.java: Demonstriere dein Admin-System! Du erhältst eine Reihe von Admin-Befehlen als einen einzelnen, durch Kommas getrennten String. Jeder Befehl folgt einem dieser Formate:
- ADD_BOOK:isbn:title:author
- REMOVE_BOOK:isbn
- REGISTER_USER:id:name
- BORROW:userId:isbn
Erstelle eine Library und einen AdminService. Verarbeite jeden Befehl und gib das Ergebnis aus:
- Für ADD_BOOK: Gib bei Erfolg Added: [title] aus.
- Für REMOVE_BOOK: Gib bei Erfolg Removed: [isbn] aus oder Cannot remove: [isbn], wenn das Buch nicht existiert oder ausgeliehen ist.
- Für REGISTER_USER: Gib Registered: [name] aus.
- Für BORROW: Verwende die bestehende Ausleihfunktion der Bibliothek.
Gib nach der Verarbeitung aller Befehle Library status: aus, gefolgt von den Details und dem Verfügbarkeitsstatus jedes Buches im Format [details] - [Available/Borrowed].

Du erhältst eine Eingabe: einen durch Kommas getrennten String mit Befehlen.

Bei der Eingabe REGISTER_USER:U001:Alice,ADD_BOOK:ISBN-001:Clean Code:Robert Martin,ADD_BOOK:ISBN-002:Design Patterns:Gang of Four,BORROW:U001:ISBN-001,REMOVE_BOOK:ISBN-001,REMOVE_BOOK:ISBN-002 würde deine Ausgabe beispielsweise wie folgt aussehen:

Registered: Alice
Added: Clean Code
Added: Design Patterns
Alice borrowed Clean Code
Cannot remove: ISBN-001
Removed: ISBN-002
Library status:
[ISBN-001] Clean Code by Robert Martin - Borrowed

Beachte, wie das Admin-Interface einen klaren Vertrag für administrative Operationen bereitstellt, während die AdminService-Implementierung die eigentliche Logik übernimmt. Das System verhindert korrekt, dass ein ausgeliehenes Buch entfernt wird, erlaubt aber das Entfernen verfügbarer Bücher. Diese Trennung von Interface und Implementierung ist ein wichtiges OOP-Prinzip, das deinen Code wartbarer und besser testbar macht!

Probier es selbst

import java.util.Scanner;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Die kommagetrennten Befehle lesen
        String input = scanner.nextLine();
        String[] commands = input.split(",");
        
        // Library und AdminService erstellen
        Library library = new Library();
        AdminService adminService = new AdminService(library);
        
        // Jeden Befehl verarbeiten
        for (String command : commands) {
            String[] parts = command.split(":");
            String operation = parts[0];
            
            if (operation.equals("ADD_BOOK")) {
                String isbn = parts[1];
                String title = parts[2];
                String author = parts[3];
                if (adminService.addBook(isbn, title, author)) {
                    System.out.println("Added: " + title);
                }
            } else if (operation.equals("REMOVE_BOOK")) {
                String isbn = parts[1];
                if (adminService.removeBook(isbn)) {
                    System.out.println("Removed: " + isbn);
                } else {
                    System.out.println("Cannot remove: " + isbn);
                }
            } else if (operation.equals("REGISTER_USER")) {
                String id = parts[1];
                String name = parts[2];
                if (adminService.registerUser(id, name)) {
                    System.out.println("Registered: " + name);
                }
            } else if (operation.equals("BORROW")) {
                String userId = parts[1];
                String isbn = parts[2];
                library.borrowBook(userId, isbn);
            }
        }
        
        // Print library status
        System.out.println("Library status:");
        ArrayList<Book> allBooks = library.getAllBooks();
        for (Book book : allBooks) {
            String status = book.isAvailable() ? "Available" : "Borrowed";
            System.out.println(book.getDetails() + " - " + status);
        }
    }
}

Alle Lektionen in Objektorientierte Programmierung

1Grundlagen der OOP

Externe Dateien Einführung in die OOP Klassen vs. Objekte Das Schlüsselwort this Methoden Felder (Attribute)Konstruktormethode Überladen von Konstruktoren Rückblick – Einfacher Taschenrechner

4Vererbung

Grundlegende Vererbung (extends)Das Schlüsselwort super Überschreiben von Methoden (@Override)Konstruktorverkettung Die Object-Klasse Einfach- und mehrstufige Vererbung Warum keine Mehrfachvererbung von Klassen Rückblick – Mitarbeiterhierarchie

7Spezielle Methoden & Object-Klasse

toString()-Methode equals() und hashCode()clone()-Methode compareTo() und Comparable Comparator-Schnittstelle Rückblick – Benutzerdefinierte Sortierung

10Exception Handling in OOP

Hierarchie der Exception-Klassen Benutzerdefinierte Exceptions Geprüfte vs. ungeprüfte Fehler Try-with-Resources-Muster Rückblick – Validierter Benutzer

13Projekt: Bibliotheksverwaltung

Projektübersicht & UML-Entwurf Buch- und Benutzerklassen Ausleihsystem SuchfunktionalitätAdministrationsoberflächeIntegration der Ausnahmebehandlung Testen und Integration

Übe selbstständig: Online-Java-Compiler