Library book catalog and constructors

import java.util.*;

public class Main {
    private static final Scanner IN = new Scanner(System.in).useLocale(Locale.ROOT);

java.util.* imports utility type names such as Scanner, Locale and collections. Main is the public class matching Main.java. The private static final IN field holds one shared Scanner for System.in; final prevents replacing that reference. The scanner uses Locale.ROOT.

    static String text() {
        if (!IN.hasNextLine()) throw new IllegalArgumentException("Incomplete input.");
        String value = IN.nextLine().trim();
        if (value.isEmpty() || value.length() > 200) throw new IllegalArgumentException("Text must have 1–200 characters.");
        return value;
    }

text checks whether a line exists, reads it and removes leading/trailing whitespace. Reject empty text and lengths above 200 by throwing IllegalArgumentException. Otherwise return the string. One field is read per line, so these helpers do not mix nextInt with leftover newlines.

    static int integer(int low, int high) {
        int value = Integer.parseInt(text());
        if (value < low || value > high) throw new IllegalArgumentException("Integer out of range.");
        return value;
    }

Integer.parseInt converts the returned string to int or throws NumberFormatException, a subtype of IllegalArgumentException. Reject values outside the caller’s inclusive low/high limits, then return the accepted integer.

    static double number(double low, double high) {
        double value = Double.parseDouble(text());
        if (!Double.isFinite(value) || value < low || value > high) throw new IllegalArgumentException("Number out of range.");
        return value;
    }

Double.parseDouble reads the string as a double. Double.isFinite rejects NaN and infinities as well as the explicit low/high range check. Return only a finite accepted value; exceptions transfer control to a matching catch block.

    static void money(String label, double value) { System.out.printf(Locale.ROOT, "%s: %.2f%n", label, value); }

money is a formatting helper: %s prints the label, %.2f prints two decimal places, and %n ends the line. Locale.ROOT fixes locale-sensitive formatting. The helper can also display non-currency quantities; it does not change the stored value.

static class Book {
        private String title, author, publisher, isbn;
        private int year;
        private double price;

Book is a static nested class, so it does not require a Main instance. Its private string, integer and double fields store the title, author, publisher, ISBN, year and price separately for each Book object.

        Book() { this("Untitled", "Unknown", "Unknown", 2026, "Not assigned", 0); }

this(...) must be the first constructor action. It supplies placeholder details and zero price to the parameterised constructor, avoiding a second copy of the initialisation rules.

        Book(String title, String author, String publisher, int year, String isbn, double price) {
            if (title == null || author == null || publisher == null || isbn == null || year < 1 || year > 9999 || !Double.isFinite(price) || price < 0 || price > 1000000)
                throw new IllegalArgumentException("Invalid book details.");
            this.title = title; this.author = author; this.publisher = publisher;
            this.year = year; this.isbn = isbn; this.price = price;
        }

The parameterised constructor rejects null text references, an unsupported year and a non-finite or out-of-range price. this.title refers to the object field rather than the same-named parameter. Store all accepted values before the constructor finishes.

        Book(Book other) { this(other.title, other.author, other.publisher, other.year, other.isbn, other.price); }

This copy constructor passes the other book’s fields to the full constructor. The new Book has its own price field. Shared String references are safe for this example because String objects are immutable.

        boolean matches(String keyword) {
            String query = keyword.toLowerCase(Locale.ROOT);
            return title.toLowerCase(Locale.ROOT).contains(query) || author.toLowerCase(Locale.ROOT).contains(query);
        }

Convert the query and stored strings to lowercase with Locale.ROOT, then use contains for substring search. Logical OR accepts a match in either field. The stored original title and author are not changed.

        void applyDiscount(double percentage) {
            if (!Double.isFinite(percentage) || percentage < 0 || percentage > 100) throw new IllegalArgumentException("Discount must be 0–100.");
            price *= 1 - percentage / 100;
        }

Require a finite percentage from 0 to 100. Multiplying price by 1 - percentage/100 keeps the undiscounted fraction. For 200 at 10%, price becomes 180. The receiver object determines which book changes.

        void displayDetails() {
            System.out.printf(Locale.ROOT, "%s | %s | %s | %d | %s | %.2f%n", title, author, publisher, year, isbn, price);
        }
    }

printf prints the fields in the supplied order and formats price to two decimal places. The last brace closes Book, not Main.

    // n, then title/author/publisher/year/isbn/price for each book, then keyword, discount.
    public static void main(String[] args) {
        try {
            int n = integer(1, 20); Book[] books = new Book[n];

The comment describes input order. public static void main is the application entry point. Inside try, require 1–20 books and reserve that many reference slots; the individual Book objects are created next.

            for (int i = 0; i < n; i++) books[i] = new Book(text(), text(), text(), integer(1, 9999), text(), number(0, 1000000));
            String keyword = text(); double discount = number(0, 100);

For every slot, read the six fields and call new Book with validated year and price values. Then read the search keyword and discount percentage.

            System.out.println("Default constructor:"); new Book().displayDetails();
            Book copy = new Book(books[0]); copy.applyDiscount(discount);
            System.out.println("Discounted copy of first book:"); copy.displayDetails();

Create and display a placeholder book. Copy the first catalog object into a new Book, discount that copy and display it. The original first book’s price remains unchanged.

            System.out.println("Original catalog:"); for (Book book : books) book.displayDetails();
            System.out.println("Search matches:"); boolean found = false;
            for (Book book : books) if (book.matches(keyword)) { book.displayDetails(); found = true; }
            if (!found) System.out.println("No matching books.");

Print the original catalog, then test each book with matches. found records whether at least one match printed. Only print the no-match message if the full scan found none.

        } catch (IllegalArgumentException e) { System.out.println("Invalid input: " + e.getMessage()); }
    }
}

The catch handles IllegalArgumentException, including invalid numeric strings from the helpers, and prints its message. The final braces close main and Main. Java objects become eligible for garbage collection when no live reference needs them; this program does not manually free them.