Testen und Integration

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

Aufgabe

Einfach

Herzlichen Glückwunsch zum Aufbau deines Bibliotheksverwaltungssystems! Jetzt ist es an der Zeit, alles zusammenzuführen und zu überprüfen, ob alle Komponenten als integriertes System korrekt funktionieren. Du wirst ein umfassendes Testszenario erstellen, das alle Funktionen ausführt, die du im Laufe dieses Projekts entwickelt hast.

Du wirst mit allen sieben Dateien deines fertiggestellten Systems arbeiten:

Book.java: Deine Book-Klasse mit isbn, title, author, isAvailable, borrowedBy und allen zugehörigen Methoden einschließlich getDetails().
User.java: Deine User-Klasse mit id, name, der borrowedBooks-Liste und Methoden zum Ausleihen und Zurückgeben von Büchern.
LibraryException.java: Deine benutzerdefinierte Basisausnahmeklasse.
BookNotAvailableException.java: Deine Ausnahme für nicht verfügbare Bücher.
LibraryAdmin.java: Deine Admin-Schnittstelle und die AdminService-Implementierung.
Library.java: Deine vollständige Library-Klasse mit allen Methoden: Hinzufügen und Entfernen von Büchern, Registrieren von Benutzern, Ausleihen und Zurückgeben, Suchen und Ausnahmebehandlung.
Main.java: Dein Integrationstest, der demonstriert, wie das gesamte System zusammenarbeitet.

In deiner Main-Klasse verarbeitest du eine Reihe von Befehlen, die alle wichtigen Funktionen deines Bibliothekssystems testen. Die Befehle werden als eine einzelne, durch Kommas getrennte Zeichenkette mit den folgenden Formaten übergeben:

ADD_BOOK:isbn:title:author – Ein Buch über AdminService hinzufügen
REGISTER_USER:id:name – Einen Benutzer über AdminService registrieren
BORROW:userId:isbn – Ein Buch ausleihen (mit Ausnahmebehandlung)
RETURN:userId:isbn – Ein Buch zurückgeben
SEARCH_TITLE:keyword – Bücher nach Titel durchsuchen
SEARCH_AUTHOR:keyword – Bücher nach Autor durchsuchen
REMOVE_BOOK:isbn – Ein Buch über AdminService entfernen

Verarbeite jeden Befehl und gib die entsprechende Ausgabe aus:

ADD_BOOK: Added: [title]
REGISTER_USER: Registered: [name]
BORROW: Gib die Erfolgsmeldung oder Error: [exception message] aus
RETURN: [userName] returned [bookTitle]
SEARCH_TITLE: Gib Search '[keyword]': aus, gefolgt von den Details jedes passenden Buchs, oder No results
SEARCH_AUTHOR: Dasselbe Format wie bei der Titelsuche
REMOVE_BOOK: Removed: [isbn] oder Cannot remove: [isbn]

Gib nach allen Befehlen eine abschließende Zusammenfassung aus:

--- Final Status ---
Books: [count]
Users: [count]
Gib für jeden Benutzer [name]: [borrowedCount] book(s) aus

Du erhältst eine Eingabe: die durch Kommas getrennte Befehlszeichenkette.

Bei der Eingabe ADD_BOOK:ISBN-001:Clean Code:Robert Martin,ADD_BOOK:ISBN-002:Effective Java:Joshua Bloch,REGISTER_USER:U001:Alice,REGISTER_USER:U002:Bob,BORROW:U001:ISBN-001,BORROW:U002:ISBN-001,SEARCH_TITLE:java,RETURN:U001:ISBN-001,REMOVE_BOOK:ISBN-001 würde deine Ausgabe beispielsweise so aussehen:

Added: Clean Code
Added: Effective Java
Registered: Alice
Registered: Bob
Alice borrowed Clean Code
Error: Book not available: ISBN-001
Search 'java':
[ISBN-002] Effective Java by Joshua Bloch
Alice returned Clean Code
Removed: ISBN-001
--- Final Status ---
Books: 1
Users: 2
Alice: 0 book(s)
Bob: 0 book(s)

Diese abschließende Herausforderung überprüft, ob alle deine Komponenten, Klassen, Schnittstellen, Ausnahmen und die Bibliothekslogik nahtlos zusammenarbeiten. Du hast ein vollständiges und robustes Bibliotheksverwaltungssystem entwickelt!

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);
        
        // Lies die durch Kommas getrennten Befehle
        String input = scanner.nextLine();
        String[] commands = input.split(",");
        
        // Erstelle Library und AdminService
        Library library = new Library();
        AdminService adminService = new AdminService(library);
        
        // Verarbeite jeden Befehl
        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];
                try {
                    String result = library.borrowBook(userId, isbn);
                    System.out.println(result);
                } catch (LibraryException e) {
                    System.out.println("Error: " + e.getMessage());
                }
            }
            // TODO: Füge Behandlung für RETURN-Befehl hinzu
            // TODO: Füge Behandlung für SEARCH_TITLE-Befehl hinzu
            // TODO: Füge Behandlung für SEARCH_AUTHOR-Befehl hinzu
        }
        
        // TODO: Gib finalen Status aus
        // --- Final Status ---
        // Bücher: [count]
        // Benutzer: [count]
        // Für jeden Benutzer: [name]: [borrowedCount] Buch/Bücher
        System.out.println("Operations completed");
    }
}

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ät Administrationsoberfläche Integration der AusnahmebehandlungTesten und Integration

Übe selbstständig: Online-Java-Compiler