Modify the library program as follows: Create a LibraryCardManager class. It sho

Question

Modify the library program as follows:

Create a LibraryCardManager class. It should contain a collection of LibraryCards and support the following operations:

   a) add new library cards
   b) lookup by ID: given an ID, return the library card associated with that ID, or null if none exist.

My Code

******************************************************

LibraryCard.java

import java.util.List;
import java.util.ArrayList;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class LibraryCard {
   private String id;
   private String cardholderName;
   private List<LibraryMaterialCopy> libraryMaterialsCheckedOut;
   private double balance;

   public LibraryCard(String i, String name) {
       id = i;
       cardholderName = name;
       libraryMaterialsCheckedOut = new ArrayList<LibraryMaterialCopy>();
       balance = 0;
   }

   public String getID() {
       return id;
   }

   public String getCardholderName() {
       return cardholderName;
   }

   public List<LibraryMaterialCopy> getlibraryMaterialsCheckedOut() {
       return new ArrayList<LibraryMaterialCopy>(libraryMaterialsCheckedOut);
   }

   public void setCardholderName(String name) {
       cardholderName = name;
   }

   public boolean checkOutLibraryMaterial(LibraryMaterialCopy libraryMaterial, LocalDate todaysDate) {
       if (!libraryMaterial.checkOut(this))
           return false;
       libraryMaterialsCheckedOut.add(libraryMaterial);
       return true;
   }

   public boolean checkOutLibraryMaterial(LibraryMaterialCopy libraryMaterial)
   // default check out, uses today's date
   {
       return checkOutLibraryMaterial(libraryMaterial, LocalDate.now());
   }

   public boolean returnLibraryMaterial(LibraryMaterialCopy libraryMaterial, LocalDate returnDate)
   // returns libraryMaterial and sends message to libraryMaterialCopy to do
   // the same
   // returns false if libraryMaterial is not checked out
   // takes parameter that expresses the date of return
   {
       LocalDate dueDate = libraryMaterial.getDueDate();
       if (!libraryMaterial.returnCopy())
           return false;
       if (!libraryMaterialsCheckedOut.remove(libraryMaterial))
           return false;
       long daysBetween = ChronoUnit.DAYS.between(dueDate, returnDate);
       if (daysBetween > 0) // libraryMaterial is returned late
       {
           balance += libraryMaterial.getFinePerDay() * daysBetween;
       }
       return true;
   }

   public boolean returnLibraryMaterial(LibraryMaterialCopy libraryMaterial)
   // default method, uses today's date as returns date
   {
       return returnLibraryMaterial(libraryMaterial, LocalDate.now());
   }

   public boolean renewLibraryMaterial(LibraryMaterialCopy libraryMaterial, LocalDate renewalDate)
   // renews libraryMaterial. Returns false if libraryMaterial is not checked
   // out already
   // takes parameter that expresses date of renewal
   // returns false if librayrMaterial is not a book
   {
       if (!libraryMaterialsCheckedOut.contains(libraryMaterial))
           return false;
       if (libraryMaterial.isRenewable()) {
           if (!((BookCopy) libraryMaterial).renew(renewalDate))
               return false;
           return true;
       }
       return false;
   }

   public boolean renewLibraryMaterial(LibraryMaterialCopy libraryMaterial)
   // default renewal method uses today's date as renewal date.
   {
       return renewLibraryMaterial(libraryMaterial, LocalDate.now());
   }

   public List<LibraryMaterialCopy> getlibraryMaterialsDueBy(LocalDate date)
   // returns an List of libraryMaterials due on or before date
   {
       List<LibraryMaterialCopy> libraryMaterialsDue = new ArrayList<LibraryMaterialCopy>();
       for (LibraryMaterialCopy libraryMaterial : libraryMaterialsCheckedOut) {
           if (libraryMaterial.getDueDate().isBefore(date) || libraryMaterial.getDueDate().equals(date)) {
               libraryMaterialsDue.add(libraryMaterial);
           }
       }

       return libraryMaterialsDue;
   }

   public List<LibraryMaterialCopy> getLibraryMaterialsOverdue(LocalDate todaysDate) {
       return getlibraryMaterialsDueBy(todaysDate.minusDays(1));
   }

   public List<LibraryMaterialCopy> getLibraryMaterialsOverdue()
   // default method, returns libraryMaterials overdue as of today, which means
   // that they
   // were due by yesterday
   {
       return getLibraryMaterialsOverdue(LocalDate.now());
   }

   public List<LibraryMaterialCopy> getLibraryMaterialsSorted()
   // returns List of libraryMaterials, sorted by due date (earliest due date
   // first)
   // uses insertion sort
   {
       List<LibraryMaterialCopy> libraryMaterials = new ArrayList<LibraryMaterialCopy>(libraryMaterialsCheckedOut);
       for (int i = 1; i < libraryMaterials.size(); i++) {
           int j = i;
           while (j > 0 && libraryMaterials.get(j - 1).getDueDate().isAfter(libraryMaterials.get(j).getDueDate())) {

               // swap elements in positions j and j-1
               LibraryMaterialCopy temp = libraryMaterials.get(j);
               libraryMaterials.set(j, libraryMaterials.get(j - 1));
               libraryMaterials.set(j - 1, temp);

               j = j - 1;
           }
       }
       return libraryMaterials;
   }
}

mainProgram.java

import java.util.ArrayList;
import java.util.List;
import java.time.LocalDate;

public class mainProgram {
   public static void main(String[] args) {
       ArrayList<LibraryMaterial> books = new ArrayList<LibraryMaterial>();
       books.add(new Book("12345678910", "Harry Potter", "J. K. Rowling"));
       books.add(new Book("98765432", "Berenstein Bears", "Stan and Jan"));
       books.add(new Book("6547901", "Curious George", "No Clue"));
       books.add(new Book("5678322222", "Samantha", "Me Myself"));

       ArrayList<LibraryMaterialCopy> bookCopies = new ArrayList<LibraryMaterialCopy>();
       for (LibraryMaterial b : books) {
           bookCopies.add(new BookCopy((Book) b));
       }

       ArrayList<LibraryCard> cards = new ArrayList<>();
       cards.add(new LibraryCard("123456", "Devorah Kletenik"));
       cards.add(new LibraryCard("87654", "Me and Me"));
       cards.add(new LibraryCard("8887654", "Sarah Kletenik"));

       for (LibraryMaterialCopy bc : bookCopies) {
           System.out.println(cards.get(0).checkOutLibraryMaterial(bc));
           System.out.println(cards.get(1).checkOutLibraryMaterial(bc));
           System.out.println(cards.get(2).checkOutLibraryMaterial(bc));
           System.out.println("Is Berenstein Bears title of the book:"+bc.isTitle("Berenstein Bears"));
       }

       List<LibraryMaterialCopy> bookCopies2 = cards.get(0).getLibraryMaterialsSorted();
       for (LibraryMaterialCopy book : bookCopies2)
           System.out.println(book.getTitle() + " " + book.getDueDate());

       System.out.println("got here");
       System.out.println(bookCopies.get(3).getTitle());
       ((BookCopy) bookCopies.get(3)).renew();

       System.out.println("renewed");

       bookCopies2 = cards.get(0).getLibraryMaterialsSorted();
       System.out.println("and here again");
       for (LibraryMaterialCopy book : bookCopies2)
           System.out.println(book.getTitle() + " " + book.getDueDate());

       System.out.println("here again");

       for (LibraryMaterialCopy bc : bookCopies) {
           System.out.println(cards.get(0).returnLibraryMaterial(bc));
           System.out.println(cards.get(1).returnLibraryMaterial(bc));
           System.out.println(cards.get(2).returnLibraryMaterial(bc));
       }

   }
}

Book.java

public class Book extends LibraryMaterial {
   private String author;

   public Book(String i, String t, String a) {
       super(i, t);
       author = a;
   }

   public String getAuthor() {
       return author;
   }

   public void print() {
       super.print();
       System.out.println("author: " + author);
   }
}

DVDCopy.java

public class DVDCopy extends LibraryMaterialCopy {
   public static final int BORROWING_WEEKS = 2;
   public static final double FINE_PER_DAY = 1;
   public static final boolean IS_RENEWABLE = false;
   private DVD dvd;

   public DVDCopy(DVD d) {
       super();
       dvd = d;
   }

   @Override
   public LibraryMaterial getLibraryMaterial() {
       return dvd;
   }

   @Override
   public String getTitle() {
       return dvd.getTitle();
   }

   @Override
   public String getISBN() {
       return dvd.getISBN();
   }

   public String getMainActor() {
       return dvd.getMainActor();
   }

   @Override
   public int getBorrowingWeeks() {
       return BORROWING_WEEKS;
   }

   @Override
   public double getFinePerDay() {
       return FINE_PER_DAY;
   }

   @Override
   public boolean isRenewable() {
       return IS_RENEWABLE;
   }

   public void print() {
       dvd.print();
       super.print();
   }

   @Override
   public boolean isTitle(String s) {
      
       if(this.dvd.getTitle().equals(s)) {
           return true;
       }
       return false;
   }
}

BookCopy.java

import java.time.*;

public class BookCopy extends LibraryMaterialCopy {
   private Book book;
   public static final int BORROWING_WEEKS = 3;
   public static final int RENEWAL_WEEKS = 2;
   public static final double FINE_PER_DAY = .10;
   public static final boolean IS_RENEWABLE = true;

   public BookCopy(Book b) {
       super();
       book = b;
   }

   @Override
   public LibraryMaterial getLibraryMaterial() {
       return book;
   }

   @Override
   public int getBorrowingWeeks() {
       return BORROWING_WEEKS;
   }

   @Override
   public double getFinePerDay() {
       return FINE_PER_DAY;
   }

   @Override
   public String getTitle() {
       return book.getTitle();
   }

   @Override
   public String getISBN() {
       return book.getISBN();
   }

   public String getAuthor() {
       return book.getAuthor();
   }

   @Override
   public boolean isRenewable() {
       return IS_RENEWABLE;
   }

   public boolean renew(LocalDate renewalDate) {
       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());
   }

   public void print() {
       book.print();
       super.print();
   }

   @Override
   public boolean isTitle(String s) {

       if(this.book.getTitle().equals(s)) {
           return true;
       }
       return false;
   }
}

LibraryMaterialCopy.java

import java.time.LocalDate;

public abstract class LibraryMaterialCopy {
   protected LibraryCard card;
   protected LocalDate dueDate;

   public LibraryMaterialCopy() {
       card = null;
       dueDate = null;
   }

   public abstract LibraryMaterial getLibraryMaterial();

   public abstract String getTitle();

   public abstract String getISBN();

   public abstract int getBorrowingWeeks();

   public abstract double getFinePerDay();

   public abstract boolean isRenewable();
  
   public abstract boolean isTitle(String s);

   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(getBorrowingWeeks());
       return true;
   }

   public boolean checkOut(LibraryCard borrower)
   // default check out method that uses todays' date
   {
       return checkOut(borrower, LocalDate.now());
   }

   public boolean returnCopy()
   // 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 void print() {
       if (card != null) {
           System.out.println("Checked out to: " + card.getCardholderName() + ", " + card.getID());
           System.out.println("Due: " + dueDate);
       }
   }
}

LibraryMaterial.java

class LibraryMaterial {
   private String ISBN;
   private String title;

   public LibraryMaterial(String i, String t) {
       ISBN = i;
       title = t;
   }

   public String getISBN() {
       return ISBN;
   }

   public String getTitle() {
       return title;
   }

   public void print() {
       System.out.print("ISBN: " + ISBN + " title: " + title + " ");
   }
  
   public boolean isTitle(String s) {
       if(this.title.equals(s)) {
           return true;
       }
       return false;
   }
}

DVD.java

public class DVD extends LibraryMaterial {
   private String mainActor;

   public DVD(String i, String t, String mA) {
       super(i, t);
       mainActor = mA;
   }

   public String getMainActor() {
       return mainActor;
   }

   public void print() {
       super.print();
       System.out.println("Main actor: " + mainActor);
   }
}

Catalog.java

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;

public class Catalog {

   HashMap<LibraryMaterial,ArrayList<LibraryMaterialCopy>> map=new HashMap<LibraryMaterial,ArrayList<LibraryMaterialCopy>>();

   public void add(LibraryMaterial m,int n)
   {
       ArrayList<LibraryMaterialCopy> copies=new ArrayList<LibraryMaterialCopy>();
      
   if(m instanceof Book)
   {
       for(int i=0;i<n;i++)
       {
           LibraryMaterialCopy c=new BookCopy((Book)m);
       copies.add(c);
       }
   }  
   else
   {
       for(int i=0;i<n;i++)
           {
               LibraryMaterialCopy c=new DVDCopy((DVD)m);
           copies.add(c);
           }
   }
     
       map.put(m,copies);
   }
  
   public Collection<LibraryMaterialCopy> lookUpByMaterial(LibraryMaterial m)
   {
       if(map.containsKey(m))
       {
           return map.get(m);
       }
      
       return null;
   }
  
   public Collection<LibraryMaterialCopy> lookUpByTitle(String title)
   {
      
       for (LibraryMaterial m : map.keySet()) {
           if(m.getTitle().equals(title))
           {
               return map.get(m);
           }
       }

       return null;
   }
  
  
   public Collection<LibraryMaterialCopy> availableCopies(LibraryMaterial m)
   {
       ArrayList<LibraryMaterialCopy>    copies=map.get(m);

       ArrayList<LibraryMaterialCopy> availablecopies=new ArrayList<LibraryMaterialCopy>() ;
      
       for(LibraryMaterialCopy c: copies)
       {
           if(c.dueDate==null)
           {
               availablecopies.add(c);
           }
       }
      

       return availablecopies;
   }

   public Collection<LibraryMaterial> availableCopies()
{
       ArrayList<LibraryMaterial> materials=new ArrayList<LibraryMaterial>(map.keySet());
       return materials;
   }
}

Explanation / Answer

PROGRAM CODE:

import java.util.ArrayList;

public class LibraryCardManager {

   private ArrayList<LibraryCard> libraryCards;

   public LibraryCardManager() {

       new ArrayList<LibraryCard>();

   }

   public void addLibraryCard(LibraryCard card)

   {

       libraryCards.add(card);

   }

   public LibraryCard getCardByID(String id)

   {

       for(LibraryCard card: libraryCards)

       {

           if(card.getID().equals(id))

               return card;

       }

       return null;

   }

}

Related Questions

Navigate

• Browse (All)
• Browse M
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.