Java: Create a book Library in Java. I have a Java code that emulates a library.
ID: 3811499 • Letter: J
Question
Java: Create a book Library in Java.
I have a Java code that emulates a library. It does simple functions such as checkout, check in, set due dates, return list if books, etc.
Revise the code to take into account the fact that libraries typically contain other materials in addition to books.
Create a LibraryMaterial class. Each LibraryMaterial consists of a title and an ISBN.* LibraryMaterialCopy has a library card and due date, but they DO NOT contain a LibraryMaterial. Instead, we're going to declare LibraryMaterialCopy an abstract class. More on this later.
***My understanding of this question is that the code needs to be revised where a new class, LibraryMaterials, should hold all the data, Book name, ISBN, Author, LibraryCard user, etc. All of which is in my Book, BookCopy and LibraryCard class. Those classes will become subclasses using inheritance to access those information. So LibraryMaterials is a superclass, with 5 subclasses, Book, BookCopy, DVD, DVDCopy and Library class. Each subclass uses inheritance to access information relating to them, such as ISBN or DVD name. This is the best I can explain it.
What sort of LibraryMaterials does the library have?
* Books. These have the same basics as a LibraryMaterial, plus an author.
* DVDs are NOT Books (for starters, they don't have authors). They are LibraryMaterials, and they have a "main actor" (on the BPL website, there is a list of "additional contributors," but I'm simplifying here).
For each type of LibraryMaterial, there is also a copy class -- Book and BookCopy, DVD and DVDCopy.
LibraryMaterialCopy is an abstract class. The reason behind this is because there's no such thing as a LibraryMaterialCopy; it must be either a Book or a DVD. So LibraryMaterial is in charge of all basic functionality for checking in and out, but is not associated with a specific LibraryMaterial at the superclass level.
The abstract LibraryMaterialCopy class should have an abstract method, getLibraryMaterial() which will return either a Book or a DVD, depending on the subclass. You may also have abstract getTitle() and getISBN().
In addition to all of the standard methods needed for accessing data and checking out / checking in / renewing / etc., each class should have a print method.
LibraryMaterials (and all superclasses) should print all of the basic information: ISBN, title and (if any): author, main actor.
LibraryMaterialCopy should print LibraryCard checked out to and dueDate.
BookCopy and DVDCopy should print all of the details of the Book/DVD plus the LibraryCard and dueDate.
Print to standard output. The only time that you should do that in a class is within a print() method.
To make matters more complicated, the library has set the following rules for checking out materials:
1. Overdue fines for books are $.10 per day, $1.00 per day for DVDs. Hint: you probably want an abstract getFinePerDay() method.
2. Books are checked out for three weeks. DVDs are checked out for only two weeks. Hint: you probably want an abstract getBorrowingPeriod() method.
3. Books are renewable for two weeks. DVDs may not be renewed.
The LibraryCard class should not have any additional functionalities, but will need to be changed to accommodate the changes to the library materials. Please think carefully about the inheritance hierarchy and polymorphism .
* Note that DVDs do not typically have ISBN and have ISAN instead, and that really the library should just give unique ID numbers to each library material . But for simplicity, we're just going to call everything ISBN
My Code
************************************************
class Book
{
private String isbn;
private String title;
private String author;
public Book (String i, String t, String a)
{
isbn = i;
title = t;
author = a;
}
public String getIsbn () {return isbn;}
public String getTitle() {return title;}
public String getAuthor() {return author;}
}
*************************************************
import java.time.LocalDate;
public class BookCopy {
public static final int BORROWING_WEEKS = 3;
public static final int RENEWAL_WEEKS = 2;
public static final double FINE_PER_DAY = .10;
private Book book;
private LibraryCard card;
private LocalDate dueDate;
public BookCopy(Book b)
{
book = b;
card = null;
dueDate = null;
}
public Book getBook() {return book;}
public String getTitle() {return book.getTitle();}
public LibraryCard getCard() {return card;}
public LocalDate getDueDate() {return dueDate;}
public boolean checkOut(LibraryCard borrower, LocalDate dateOfBorrowing)
/*checks book out by setting card reference to borrower.
returns false if book is already checked out
sets due date to BORROWING_WEEKS after current date passed */
{
if (card != null)
return false;
card = borrower;
dueDate = dateOfBorrowing.plusWeeks(BORROWING_WEEKS);
return true;
}
public boolean checkOut (LibraryCard borrower)
//default check out method that uses todays' date
{
return checkOut(borrower, LocalDate.now());
}
public boolean returnBook()
//returns book by removing card reference
//returns false if there is no reference to a card
{
if (card == null)
return false;
card = null;
return true;
}
public boolean renew (LocalDate renewalDate)
//renews book using RENEWAL_WEEKS as interval
//returns false if books is not checked out
{
if (card == null)
return false;
dueDate = renewalDate.plusWeeks(RENEWAL_WEEKS);
return true;
}
public boolean renew ()
//default method uses todays date as renewal date
{
return renew(LocalDate.now());
}
}
************************************************
import java.util.ArrayList;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
public class LibraryCard {
private String id;
private String cardholderName;
private ArrayList booksCheckedOut;
private double balance;
public LibraryCard(String i, String name)
{
id = i;
cardholderName = name;
booksCheckedOut = new ArrayList();
balance = 0;
}
public String getID() {return id;}
public String getCardholderName() {return cardholderName;}
public ArrayList getBooksCheckedOut() {return booksCheckedOut;}
public void setCardholderName (String name) {cardholderName = name;}
public boolean checkOutBook (BookCopy book, LocalDate todaysDate)
//checks out book and sends message to BookCopy to check itself out too
//returns false if book is already checked out
//takes parameter that reflects the date that the checkout is happening
{
if (!book.checkOut(this,todaysDate)
return false;
booksCheckedOut.add(book);
return true;
}
public boolean checkOutBook(BookCopy book)
//default check out, uses today's date
{
return checkOutBook(book, LocalDate.now());
}
public boolean returnBook (BookCopy book, LocalDate returnDate)
//returns book and sends message to BookCopy to do the same
//returns false if book is not checked out
//takes parameter that expresses the date of return
{
LocalDate dueDate = book.getDueDate();
if (!book.returnBook())
return false;
if (!booksCheckedOut.remove(book))
return false;
long daysBetween = ChronoUnit.DAYS.between(dueDate, returnDate);
if (daysBetween > 0) //book is returned late
{
balance += BookCopy.FINE_PER_DAY * daysBetween;
}
return true;
}
public boolean returnBook (BookCopy book)
//default method, uses today's date as returns date
{
return returnBook(book, LocalDate.now());
}
public boolean renewBook(BookCopy book, LocalDate renewalDate)
//renews book. Returns false if book is not checked out already
//takes parameter that expresses date of renewal
{
if (!booksCheckedOut.contains(book))
return false;
if (!book.renew(renewalDate))
return false;
return true;
}
public boolean renewBook (BookCopy book)
//default renewal method uses today's date as renewal date.
{
return renewBook(book, LocalDate.now());
}
public ArrayList getBooksDueBy(LocalDate date)
//returns an ArrayList of books due on or before date
{
ArrayList booksDue = new ArrayList();
for (BookCopy book: booksCheckedOut)
{
if (book.getDueDate().isBefore(date) || book.getDueDate().equals(date))
{
booksDue.add(book);
}
}
return booksDue;
}
public ArrayList getBooksOverdue (LocalDate todaysDate)
//returns books overdue as of todaysDate
//which means that they were actually due by yesterday
{
return getBooksDueBy(todaysDate.minusDays(1));
}
public ArrayList getBooksOverdue()
//default method, returns books overdue as of today, which means that they
//were due by yesterday
{
return getBooksOverdue(LocalDate.now());
}
public ArrayList getBooksSorted()
//returns ArrayList of books, sorted by due date (earliest due date first)
//uses insertion sort
{
for (int i = 1; i < booksCheckedOut.size(); i++)
{
int j = i;
while (j > 0 && booksCheckedOut.get(j-1).getDueDate().isAfter(booksCheckedOut.get(j).getDueDate()))
{
//swap elements in positions j and j-1
BookCopy temp = booksCheckedOut.get(j);
booksCheckedOut.set(j, booksCheckedOut.get(j-1));
booksCheckedOut.set(j-1, temp);
j = j-1;
}
}
return booksCheckedOut;
}
}
Explanation / Answer
DriverProgram.java
import java.util.*;
import java.time.*;
public class DriverProgram {
public static void main (String[] args) {
//assign values to the LibraryMaterial subclasses -Randolph Cisneros
Book catHat = new Book("001","Cat hat", "Seuss");
Book lionWitch = new Book("002","Lion Witch", "Lewis");
Book gatsby = new Book("003","Gatsby", "Fitzgerald");
Book wonka = new Book("004","Wonka", "Dahl");
DVD catInHat = new DVD("005","Cat hat", "Meyers");
DVD batMan = new DVD("006","Batman", "Ledger");
DVD rickMorty = new DVD("007","Rick and Morty", "Harmon");
DVD imitationGame = new DVD("008","The Imitation Game", "Cumberbatch");
//assign LibraryMaterial to the LibraryMaterialCopy subclasses -Randolph Cisneros
BookCopy lW= new BookCopy(lionWitch);
BookCopy gat= new BookCopy(gatsby);
BookCopy won = new BookCopy(wonka);
BookCopy cH = new BookCopy(catHat);
DVDCopy cIH = new DVDCopy(catInHat);
DVDCopy bM = new DVDCopy(batMan);
DVDCopy rM = new DVDCopy(rickMorty);
DVDCopy iG = new DVDCopy(imitationGame);
//assign cardholders. Really can just do with one. -Randolph Cisneros
LibraryCard bobSmith = new LibraryCard("01","Bob Smith");
LibraryCard janeDoe = new LibraryCard("02","Jane Doe");
LibraryCard johnDoe = new LibraryCard("03","John Doe");
//testerDates -Randolph Cisneros
LocalDate today = LocalDate.now();
LocalDate earlyDueDate = today.minusWeeks(5);
//some material is given early checkout dates to test the late return methods -Randolph Cisneros
janeDoe.
checkOutLibraryMaterial(gat, today);
janeDoe.checkOutLibraryMaterial(lW, earlyDueDate);
janeDoe.checkOutLibraryMaterial(won, earlyDueDate);
janeDoe.checkOutLibraryMaterial(cH, earlyDueDate);
janeDoe.checkOutLibraryMaterial(cIH, today);
janeDoe.checkOutLibraryMaterial(iG, earlyDueDate);
//this block tests a dvd for renewal; it should print a message -Randolph Cisneros
janeDoe.renewLibraryMaterial(gat);
janeDoe.renewLibraryMaterial(iG);
//checks these in to system -Randolph Cisneros
janeDoe.returnLibraryMaterial(gat);
janeDoe.returnLibraryMaterial(lW);
//tests list sort -Randolph Cisneros
ArrayList<LibraryMaterialCopy> mainSortedList = janeDoe.getLibraryMaterialSorted();
traverseAndPrintDate(mainSortedList);
//tests the method to get overdue material -Randolph Cisneros
ArrayList<LibraryMaterialCopy> lateLibraryMaterial = janeDoe.getLibraryMaterialOverdue();
traverseAndPrintDate(lateLibraryMaterial);
}
//Simple traverse and print method. Makes use of print methods in the classes -Randolph Cisneros
public static void traverseAndPrintDate(ArrayList<LibraryMaterialCopy> libraryMaterialList){
for (int i = 0; i < libraryMaterialList.size(); i++){
LibraryMaterialCopy itLibraryMaterialCopy = libraryMaterialList.get(i);
LibraryMaterial itLibraryMaterial = itLibraryMaterialCopy.getLibraryMaterial();
itLibraryMaterial.print();
itLibraryMaterialCopy.print();
}
}
}
Book.java
class Book extends LibraryMaterial
{
private String author;
//constructor for Book calls constructor for superclass first -Randolph Cisneros
public Book (String i, String t, String a)
{
super(i,t);
author = a;
}
//mutators actually need to call super to access elements of superclass -Randolph Cisneros
public String getIsbn () {return super.getIsbn();}
public String getTitle() {return super.getTitle();}
public String getAuthor() {return author;}
//print method -Randolph Cisneros
public void print() {
super.print();
System.out.println("Author: " + getAuthor());
}
}
LibraryMaterial.java
public class LibraryMaterial {
private String title;
private String ISBN;
//constructor for LibraryMaterial class; must use super(i,t) in sublcasses -Randolph Cisneros
public LibraryMaterial(String i, String t){
ISBN = i;
title = t;
}
//accessors. This is the highest level and has direct access to title and ISBN -Randolph Cisneros
public String getTitle() {return title;}
public String getIsbn() {return ISBN; }
//print method -Randolph Cisneros
public void print(){
System.out.println("Title: " + title + "ISBN: " + ISBN);
}
}
BookCopy.java
import java.time.LocalDate;
public class BookCopy extends LibraryMaterialCopy {
public static final int BORROWING_WEEKS = 3;
public static final int RENEWAL_WEEKS = 2;
public static final double FINE_PER_DAY = .10;
private Book book;
private LibraryCard card;
private LocalDate dueDate;
public BookCopy(Book b)
{
book = b;
card = null;
dueDate = null;
}
//accessors. we also need access to static variables because they will be different
//between subclasses -Randolph Cisneros
public LibraryMaterial getLibraryMaterial() {return book;}
public String getTitle() {return book.getTitle();}
public String getIsbn() {return book.getIsbn();}
public LibraryCard getCard() {return card;}
public LocalDate getDueDate() {return dueDate;}
public double getFinePerDay(){ return FINE_PER_DAY; }
public int getBorrowingPeriod() { return BORROWING_WEEKS; }
public boolean checkOut(LibraryCard borrower, LocalDate dateOfBorrowing)
/*checks book out by setting card reference to borrower.
returns false if book is already checked out
sets due date to BORROWING_WEEKS after current date passed -Randolph Cisneros */
{
if (card != null)
return false;
card = borrower;
dueDate = dateOfBorrowing.plusWeeks(BORROWING_WEEKS);
return true;
}
public boolean checkOut (LibraryCard borrower)
//default check out method that uses todays' date -Randolph Cisneros
{
return checkOut(borrower, LocalDate.now());
}
public boolean returnLibraryMaterial()
//returns book by removing card reference
//returns false if there is no reference to a card -Randolph Cisneros
{
if (card == null)
return false;
card = null;
return true;
}
public boolean renew (LocalDate renewalDate)
//renews book using RENEWAL_WEEKS as interval
//returns false if books is not checked out -Randolph Cisneros
{
if (card == null)
return false;
dueDate = renewalDate.plusWeeks(RENEWAL_WEEKS);
return true;
}
public boolean renew ()
//default method uses todays date as renewal date -Randolph Cisneros
{
return renew(LocalDate.now());
}
//users other class's method, which calls super class's print method -Randolph Cisneros
public void print()
{
book.print();
LibraryCard c = getCard();
LocalDate dD = getDueDate();
System.out.println("Card: " + c.getCardholderName() + "Due Date: " + dD.toString());
}
}
LibraryMaterialCopy.java
import java.time.LocalDate;
public abstract class LibraryMaterialCopy {
private LibraryCard card;
private LocalDate dueDate;
public LibraryMaterialCopy() {
card = null;
dueDate = null;
}
//Many abstract classes had to be added in order to replace BookCopy with LibraryMaterialCopy in the
//LibraryCard class. This is something to note when replacing a class with an abstract class. -Randolph Cisneros
abstract LibraryMaterial getLibraryMaterial();
abstract String getTitle();
abstract String getIsbn();
abstract LocalDate getDueDate();
abstract boolean returnLibraryMaterial();
abstract boolean renew();
abstract boolean renew(LocalDate date);
abstract boolean checkOut(LibraryCard borrower, LocalDate dateOfBorrowing);
abstract boolean checkOut (LibraryCard borrower);
//accessors for 2 different static final values of the subclasses; allows for polymorphism -Randolph Cisneros
abstract double getFinePerDay();
abstract int getBorrowingPeriod();
abstract void print();
}
LibraryCard.java
import java.util.ArrayList;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
//A lot of changes were pretty much just swapping Book with LibraryMaterial, though there were some methods
//pertaining to the LibraryMaterialCopy class that I forgot to implement and didn't find out until I tried
//to compile this class. -Randolph Cisneros
public class LibraryCard {
private String id;
private String cardholderName;
private ArrayList<LibraryMaterialCopy> libraryMaterialCheckedOut;
private double balance;
public LibraryCard(String i, String name)
{
id = i;
cardholderName = name;
libraryMaterialCheckedOut = new ArrayList<LibraryMaterialCopy>();
balance = 0;
}
//accessors -Randolph Cisneros
public String getID() {return id;}
public String getCardholderName() {return cardholderName;}
public ArrayList<LibraryMaterialCopy> getlibraryMaterialCheckedOut() {return libraryMaterialCheckedOut;}
//mutator -Randolph Cisneros
public void setCardholderName (String name) {cardholderName = name;}
public boolean checkOutLibraryMaterial (LibraryMaterialCopy lM, LocalDate todaysDate)
//checks out LibraryMaterial and sends message to LibraryCopy to check itself out too
//returns false if lM is already checked out
//takes parameter that reflects the date that the checkout is happening -Randolph Cisneros
{
if (!lM.checkOut(this,todaysDate))
return false;
libraryMaterialCheckedOut.add(lM);
return true;
}
public boolean checkOutLibraryMaterial(LibraryMaterialCopy lM)
//default check out, uses today's date -Randolph Cisneros
{
return checkOutLibraryMaterial(lM, LocalDate.now());
}
public boolean returnLibraryMaterial (LibraryMaterialCopy lM, LocalDate returnDate)
//returns lM and sends message to LibraryMaterialCopy to do the same
//returns false if lM is not checked out
//takes parameter that expresses the date of return -Randolph Cisneros
{
LocalDate dueDate = lM.getDueDate();
if (!lM.returnLibraryMaterial())
return false;
if (!libraryMaterialCheckedOut.remove(lM))
return false;
long daysBetween = ChronoUnit.DAYS.between(dueDate, returnDate);
if (daysBetween > 0) //book is returned late
{
balance += lM.getFinePerDay() * daysBetween;
}
return true;
}
public boolean returnLibraryMaterial (LibraryMaterialCopy lM)
//default method, uses today's date as returns date -Randolph Cisneros
{
return returnLibraryMaterial(lM, LocalDate.now());
}
public boolean renewLibraryMaterial(LibraryMaterialCopy lM, LocalDate renewalDate)
//renews lM. Returns false if lM is not checked out already
//takes parameter that expresses date of renewal -Randolph Cisneros
{
if (!libraryMaterialCheckedOut.contains(lM))
return false;
if (!lM.renew(renewalDate))
return false;
return true;
}
public boolean renewLibraryMaterial (LibraryMaterialCopy lM)
//default renewal method uses today's date as renewal date. -Randolph Cisneros
{
return renewLibraryMaterial(lM, LocalDate.now());
}
public ArrayList<LibraryMaterialCopy> getLibraryMaterialDueBy(LocalDate date)
//returns an ArrayList of LibraryMaterial due on or before date -Randolph Cisneros
{
ArrayList<LibraryMaterialCopy> LibraryMaterialDue = new ArrayList();
for (LibraryMaterialCopy lM: libraryMaterialCheckedOut)
{
if (lM.getDueDate().isBefore(date) || lM.getDueDate().equals(date))
{
LibraryMaterialDue.add(lM);
}
}
return LibraryMaterialDue;
}
public ArrayList<LibraryMaterialCopy> getLibraryMaterialOverdue (LocalDate todaysDate)
//returns LibraryMaterial overdue as of todaysDate
//which means that they were actually due by yesterday -Randolph Cisneros
{
return getLibraryMaterialDueBy(todaysDate.minusDays(1));
}
public ArrayList getLibraryMaterialOverdue()
//default method, returns LibraryMaterial overdue as of today, which means that they
//were due by yesterday -Randolph Cisneros
{
return getLibraryMaterialOverdue(LocalDate.now());
}
public ArrayList<LibraryMaterialCopy> getLibraryMaterialSorted()
//returns ArrayList of LibraryMaterial, sorted by due date (earliest due date first)
//uses insertion sort -Randolph Cisneros
{
for (int i = 1; i < libraryMaterialCheckedOut.size(); i++)
{
int j = i;
while (j > 0 && libraryMaterialCheckedOut.get(j-1).getDueDate().isAfter(libraryMaterialCheckedOut.get(j).getDueDate()))
{
//swap elements in positions j and j-1
LibraryMaterialCopy temp = libraryMaterialCheckedOut.get(j);
libraryMaterialCheckedOut.set(j, libraryMaterialCheckedOut.get(j-1));
libraryMaterialCheckedOut.set(j-1, temp);
j = j-1;
}
}
return libraryMaterialCheckedOut;
}
}
DVD.java
class DVD extends LibraryMaterial {
private String mainActor;
public DVD (String i, String t, String mA) {
super(i,t);
mainActor = mA;
}
//accessors for subclass call accessors for superclass if necessary -Randolph Cisneros
public String getIsbn () {return super.getIsbn();}
public String getTitle() {return super.getTitle();}
public String getMainActor() {return mainActor;}
//print method, calls super first. -Randolph Cisneros
public void print() {
super.print();
System.out.println("Main Actor: " + mainActor);
}
}
DVDCopy.java
import java.time.LocalDate;
public class DVDCopy extends LibraryMaterialCopy {
public static final int BORROWING_WEEKS = 2;
public static final double FINE_PER_DAY = 1.00;
private DVD dvd;
private LibraryCard card;
private LocalDate dueDate;
public DVDCopy(DVD d)
{
dvd = d;
card = null;
dueDate = null;
}
//Accessors. Note that they call accessors to the other class as well -Randolph Cisneros
public LibraryMaterial getLibraryMaterial() {return dvd;}
public String getTitle() {return dvd.getTitle();}
public String getIsbn() { return dvd.getIsbn();}
public LibraryCard getCard() {return card;}
public LocalDate getDueDate() {return dueDate;}
//Here again, we have accessors for the public static variables. It
//seems like this would be a smart standard practice, especially for
//any subclass. -Randolph Cisneros
public double getFinePerDay(){ return FINE_PER_DAY; }
public int getBorrowingPeriod() { return BORROWING_WEEKS; }
public boolean checkOut(LibraryCard borrower, LocalDate dateOfBorrowing)
/*checks dvd out by setting card reference to borrower.
returns false if dvd is already checked out
sets due date to BORROWING_WEEKS after current date passed -Randolph Cisneros */
{
if (card != null)
return false;
card = borrower;
dueDate = dateOfBorrowing.plusWeeks(BORROWING_WEEKS);
return true;
}
public boolean checkOut (LibraryCard borrower)
//default check out method that uses todays' date -Randolph Cisneros
{
return checkOut(borrower, LocalDate.now());
}
public boolean returnLibraryMaterial()
//returns dvd by removing card reference
//returns false if there is no reference to a card
{
if (card == null)
return false;
card = null;
return true;
}
//a simple class that returns false. I decided to override this method rather than omit,
//since it felt like a safer bet -Randolph Cisneros
public boolean renew (LocalDate renewDate){
System.out.println("Cannot renew DVDs");
return false;
}
public boolean renew ()
{
System.out.println("Cannot renew DVDs");
return false;
}
//print method for this class. uses dvd print method, then has to create local librarycard and duedate variables
//to use their accessors -Randolph Cisneros
public void print() {
dvd.print();
LibraryCard c = getCard();
LocalDate dD = getDueDate();
System.out.println("Card: " + c.getCardholderName() + "Due Date" + dD.toString());
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.