Interfaccia amministratore

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 81 di 87.

Sfida

Facile

Espandiamo il tuo sistema di gestione della biblioteca con un'interfaccia amministrativa! Una vera biblioteca ha bisogno di funzionalità amministrative: aggiungere nuovi libri alla collezione, rimuovere quelli obsoleti e registrare nuovi membri. Creerai un'interfaccia che definisce queste operazioni amministrative e le implementerai in una classe amministrativa dedicata.

Continuerai a lavorare sul codice esistente in cinque file:

Book.java: Mantieni la tua classe Book con tutte le funzionalità esistenti: isbn, title, author, isAvailable, borrowedBy, getDetails() e i getter/setter appropriati.
User.java: Mantieni invariata la tua classe User con id, name, l'ArrayList borrowedBooks, borrowBook(), returnBook(), getBorrowedCount() e toString().
Library.java: Mantieni la tua classe Library con tutti i metodi esistenti. Aggiungi un nuovo metodo removeBook(String isbn) che individua e rimuove un libro dalla collezione usando il suo ISBN. Il metodo dovrebbe restituire true se il libro è stato trovato e rimosso, false altrimenti. Un libro può essere rimosso solo se è attualmente disponibile (non in prestito).
LibraryAdmin.java: Crea un'interfaccia chiamata LibraryAdmin che definisca il contratto per le operazioni amministrative. La tua interfaccia dovrebbe dichiarare tre metodi:
- addBook(String isbn, String title, String author) - restituisce un booleano che indica il successo
- removeBook(String isbn) - restituisce un booleano che indica il successo
- registerUser(String id, String name) - restituisce un booleano che indica il successo
Quindi crea una classe chiamata AdminService che implementa questa interfaccia. AdminService dovrebbe mantenere un riferimento a una Library (passato tramite il suo costruttore) e implementare tutti e tre i metodi delegandoli a Library e fornendo un riscontro appropriato. Quando aggiungi un libro, crea una nuova Book e aggiungila alla biblioteca. Quando registri un utente, crea un nuovo User e registralo.
Main.java: Mostra il funzionamento del tuo sistema amministrativo! Riceverai una serie di comandi amministrativi come un'unica stringa separata da virgole. Ogni comando segue uno dei seguenti formati:
- ADD_BOOK:isbn:title:author
- REMOVE_BOOK:isbn
- REGISTER_USER:id:name
- BORROW:userId:isbn
Crea una Library e un AdminService. Elabora ogni comando e stampa il risultato:
- Per ADD_BOOK: in caso di successo, stampa Added: [title]
- Per REMOVE_BOOK: in caso di successo, stampa Removed: [isbn], oppure Cannot remove: [isbn] se il libro non esiste o è in prestito
- Per REGISTER_USER: stampa Registered: [name]
- Per BORROW: usa la funzionalità di prestito esistente della biblioteca
Dopo aver elaborato tutti i comandi, stampa Library status: seguito dai dettagli di ogni libro e dal relativo stato di disponibilità nel formato [details] - [Available/Borrowed].

Riceverai un input: una stringa di comandi separati da virgole.

Ad esempio, con l'input 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, l'output sarà:

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

Nota come l'interfaccia amministrativa fornisca un contratto chiaro per le operazioni amministrative, mentre l'implementazione di AdminService gestisce la logica effettiva. Il sistema impedisce correttamente di rimuovere un libro in prestito, consentendo invece la rimozione di quelli disponibili. Questa separazione tra interfaccia e implementazione è un principio fondamentale della programmazione orientata agli oggetti che rende il codice più facile da mantenere e testare!

Provalo tu

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

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leggi i comandi separati da virgole
        String input = scanner.nextLine();
        String[] commands = input.split(",");
        
        // Crea Library e AdminService
        Library library = new Library();
        AdminService adminService = new AdminService(library);
        
        // Elabora ogni comando
        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);
            }
        }
        
        // Stampa lo stato della biblioteca
        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);
        }
    }
}

Tutte le lezioni di Programmazione orientata agli oggetti

1Fondamenti della programmazione a oggetti

File esterni Introduzione alla programmazione a oggetti Classi e oggetti La parola chiave this Metodi Campi (attributi)Metodo costruttore Sovraccarico dei costruttori Ripasso - Calcolatrice semplice

4Ereditarietà

Ereditarietà di base (extends)La parola chiave super Sovrascrittura dei metodi (@Override)Concatenamento dei costruttori La classe Object Ereditarietà singola e multilivello Perché non esiste l'ereditarietà multipla delle classi Riepilogo: gerarchia dei dipendenti

7Metodi speciali e classe Object

Metodo toString()equals() e hashCode()Metodo clone()compareTo() e Comparable Interfaccia Comparator Riepilogo - Ordinamento personalizzato

10Gestione delle eccezioni in OOP

Gerarchia delle classi di eccezione Eccezioni personalizzate Eccezioni controllate e non controllate Pattern try-with-resources Riepilogo - Utente validato

13Progetto: Gestione della biblioteca

Panoramica del progetto e progettazione UML Classi Libro e Utente Sistema di prestito Funzionalità di ricercaInterfaccia amministratoreIntegrazione della gestione delle eccezioni Test e integrazione

Esercitati da solo: Compilatore Java online