Library Management System Project
I
INFORMATION TECHNOLOGY
Project Title: Library Management System using Java
By: Shivamihit G, Gowtham P A, Pranil Kumar G V
Course / Class: IT / Project Work
Year: 2025-26
.
Abstract
The Library Management System (LMS) is an innovative project
developed using Java, designed to simplify and automate the
management of library operations. The system provides an
integrated solution for managing book records, user details,
transactions, and fine calculations. Built with a combination of
Java, MySQL, and Swing (for GUI), the project demonstrates how
Java’s versatility and platform independence make it ideal for
real-world applications.
This project aims to replace the traditional manual record-keeping
methods used in libraries with a computerized system that offers
improved efficiency, speed, and data accuracy. The system
includes key features such as book registration, student
registration, issue and return modules, fine management, and
advanced search functionalities. By leveraging object-oriented
programming concepts, the system maintains clean and reusable
code that can be easily extended for additional functionalities.
The LMS is designed with modularity and user-friendliness in
mind. Administrators can manage inventory, generate reports,
and track user activity, while users can access information on
book availability and manage their borrowing records. Java’s
exception handling, JDBC connectivity, and graphical interface
support ensure the project’s robustness and flexibility.
Moreover, this project showcases the importance of Java in
software development for academic, professional, and enterprise-
level applications. Java’s scalability allows for future
enhancements such as integration with RFID technology, online
book reservations, mobile app extensions, and cloud-based
synchronization.
Table of Contents
1. Introduction to Java
2. Project Overview
3. Tools & Technologies
4. Requirements Specification
5. System Design (ER, UML)
6. Database Schema
7. Implementation Details (Code)
8. GUI Screenshots & Preview Images
9. Innovations
10. Testing and Output
11. Conclusion: Use of Java
12. Bibliography
1. Introduction to Java
Java is a high-level, class-based, object-oriented
programming language designed to have as few
implementation dependencies as possible. Key features:
Platform independence (JVM)
Strong OOP principles
Rich standard library
Robust memory management (garbage collection)
Good for desktop apps, backend services, Android
apps, and more
Why Java for this project:
Excellent JDBC support for database connectivity
Mature GUI toolkits (Swing, JavaFX)
Widespread use in education and industry
2. Project Overview
The Library Management System (LMS) is designed to
digitize and simplify all key library functions in schools,
colleges, and public libraries. It serves as an efficient tool
for managing library resources, eliminating the traditional
paper-based record-keeping system. The system provides
real-time tracking of books, members, and transactions
while ensuring data accuracy and security.
Key Features of the Project
Centralized Data Management: All data regarding
books, members, and transactions are stored in a
single database, enabling quick access and updates.
User-Friendly Interface: The GUI, designed using Java
Swing, is intuitive and easy to navigate for both
librarians and users.
Secure Authentication: The login module ensures
that only authorized personnel can access the admin
panel.
Efficient Record Handling: Allows adding, updating,
and deleting records with instant reflection in the
database.
Fine Calculation System: Automatically calculates
overdue fines based on the issue and return dates.
Reporting and Analytics: Generates reports of issued
and returned books, student activities, and book
availability.
Search and Filter Options: Users can search for books
by title, author, or publisher quickly.
Innovative Elements
The project can be enhanced with barcode or QR
code scanning for quick book identification.
Email or SMS reminders can be integrated to notify
users about due dates.
Data encryption and backup mechanisms ensure
long-term data safety.
The application architecture supports future
migration to a web or mobile platform.
Overall, the LMS not only showcases the practical
implementation of Java and MySQL integration but also
demonstrates software development best practices such
as modularity, exception handling, and scalability.
System Design and Architecture
The system is designed using a modular approach,
dividing the project into several interdependent modules:
1. Login Module: Handles authentication of admin and
user.
2. Book Management Module: Adds, updates, deletes,
and views book records.
3. Member Management Module: Registers and
manages library members.
4. Transaction Module: Manages book issue and return
records.
5. Report Module: Generates reports on issued books,
fines, and member activity.
3. Tools & Technologies
Java Development Kit (JDK 11 or later recommended)
IDE: IntelliJ IDEA / Eclipse / NetBeans
Database: MySQL / SQLite (both options provided)
Build: optionally Maven or Gradle
GUI: Java Swing (primary) — JavaFX optional
4. Requirements Specification
Functional Requirements: 1. Manage books (CRUD) 2.
Manage members (CRUD) 3. Issue & return books 4.
Search functionality 5. Generate simple reports
Non-Functional Requirements: - Data persistence via
RDBMS - Usable GUI - Basic input validation
5. System Design — ER Diagram
(Insert ER diagram here)
Placeholder for preview image:
Description: - Entities: Book, Member, Issue -
Relationships: Member issues Book (many-to-many
implemented with Issue table)
6. Database Schema
Using simple SQL — compatible with MySQL and SQLite.
-- Books table
CREATE TABLE books (
book_id INT PRIMARY KEY AUTO_INCREMENT,
isbn VARCHAR(20) UNIQUE,
title VARCHAR(255) NOT NULL,
author VARCHAR(255),
publisher VARCHAR(255),
year INT,
copies INT DEFAULT 1
);
-- Members table
CREATE TABLE members (
member_id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
email VARCHAR(255),
phone VARCHAR(20),
address TEXT
);
-- Issues table
CREATE TABLE issues (
issue_id INT PRIMARY KEY AUTO_INCREMENT,
book_id INT NOT NULL,
member_id INT NOT NULL,
issue_date DATE NOT NULL,
due_date DATE NOT NULL,
return_date DATE,
FOREIGN KEY (book_id) REFERENCES
books(book_id),
FOREIGN KEY (member_id) REFERENCES
members(member_id)
);
For SQLite, replace AUTO_INCREMENT with AUTOINCREMENT
and types slightly.
7. Implementation Details — Project Structure
Suggested package layout:
|-- Main.java
|-- model
| |-- Book.java
| |-- Member.java
| |-- Issue.java
|-- dao
| |-- DBConnection.java
| |-- BookDAO.java
| |-- MemberDAO.java
| |-- IssueDAO.java
|-- ui
|-- MainFrame.java
|-- BookPanel.java
|-- MemberPanel.java
|-- IssuePanel.java
7.1 DBConnection.java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DBConnection {
private static final String URL =
"jdbc:mysql://localhost:3306/librarydb";
private static final String USER = "root";
private static final String PASS =
"password";
public static Connection getConnection()
throws SQLException {
return DriverManager.getConnection(URL,
USER, PASS);
}
}
Note: For SQLite use jdbc:sqlite:library.db and no
username/password.
7.2 Model Classes — Book.java
public class Book {
private int bookId;
private String isbn;
private String title;
private String author;
private String publisher;
private int year;
private int copies;
// Constructors
public Book() {}
public Book(String isbn, String title,
String author, String publisher, int year, int
copies) {
this.isbn = isbn;
this.title = title;
this.author = author;
this.publisher = publisher;
this.year = year;
this.copies = copies;
}
// Getters and setters
// ... (generated)
}
7.3 BookDAO.java (CRUD operations)
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class BookDAO {
public void addBook(Book book) throws
SQLException {
String sql = "INSERT INTO
books(isbn,title,author,publisher,year,copies)
VALUES(?,?,?,?,?,?)";
try (Connection conn =
DBConnection.getConnection();
PreparedStatement ps =
conn.prepareStatement(sql)) {
ps.setString(1, book.getIsbn());
ps.setString(2, book.getTitle());
ps.setString(3, book.getAuthor());
ps.setString(4,
book.getPublisher());
ps.setInt(5, book.getYear());
ps.setInt(6, book.getCopies());
ps.executeUpdate();
}
}
public List<Book> getAllBooks() throws
SQLException {
List<Book> list = new ArrayList<>();
String sql = "SELECT * FROM books";
try (Connection conn =
DBConnection.getConnection();
Statement st =
conn.createStatement();
ResultSet rs =
st.executeQuery(sql)) {
while (rs.next()) {
Book b = new Book();
b.setBookId(rs.getInt("book_id"));
b.setIsbn(rs.getString("isbn"));
b.setTitle(rs.getString("title"));
b.setAuthor(rs.getString("author"));
b.setPublisher(rs.getString("publisher"));
b.setYear(rs.getInt("year"));
b.setCopies(rs.getInt("copies"));
list.add(b);
}
}
return list;
}
// updateBook, deleteBook, findByISBN
methods (similar structure) ...
}
7.4 Member.java & MemberDAO.java (summarized)
Member.java (fields: memberId, name, email, phone,
address) — standard getters/setters.
MemberDAO.java — methods: addMember(Member),
getAllMembers(), updateMember(…), deleteMember(…)
Example addMember snippet:
public void addMember(Member m) throws
SQLException {
String sql = "INSERT INTO
members(name,email,phone,address)
VALUES(?,?,?,?)";
try (Connection conn =
DBConnection.getConnection(); PreparedStatement
ps = conn.prepareStatement(sql)) {
ps.setString(1, m.getName());
ps.setString(2, m.getEmail());
ps.setString(3, m.getPhone());
ps.setString(4, m.getAddress());
ps.executeUpdate();
}
}
7.5 IssueDAO.java (issue / return logic)
public class IssueDAO {
public void issueBook(int bookId, int
memberId, Date issueDate, Date dueDate) throws
SQLException {
String sql = "INSERT INTO
issues(book_id, member_id, issue_date, due_date)
VALUES(?,?,?,?)";
try (Connection conn =
DBConnection.getConnection(); PreparedStatement
ps = conn.prepareStatement(sql)) {
ps.setInt(1, bookId);
ps.setInt(2, memberId);
ps.setDate(3, new
java.sql.Date(issueDate.getTime()));
ps.setDate(4, new
java.sql.Date(dueDate.getTime()));
ps.executeUpdate();
}
// optionally decrement available copies
in books table
}
public void returnBook(int issueId, Date
returnDate) throws SQLException {
String sql = "UPDATE issues SET
return_date = ? WHERE issue_id = ?";
try (Connection conn =
DBConnection.getConnection(); PreparedStatement
ps = conn.prepareStatement(sql)) {
ps.setDate(1, new
java.sql.Date(returnDate.getTime()));
ps.setInt(2, issueId);
ps.executeUpdate();
}
// optionally increment available copies
}
}
7.6 Simple CLI Main.java (for quick testing)
public class Main {
public static void main(String[] args) {
BookDAO dao = new BookDAO();
try {
Book b = new Book("978-
0135166307","Effective Java","Joshua
Bloch","Pearson",2018,3);
dao.addBook(b);
System.out.println("Book added
successfully");
} catch (Exception e) {
e.printStackTrace();
}
}
}
Preview image placeholder: ![CLI Output]
(images/cli_output.png)
7.7 GUI — MainFrame.java (Swing)
import javax.swing.*;
import java.awt.*;
public class MainFrame extends JFrame {
public MainFrame() {
setTitle("Library Management System");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(900,600);
setLocationRelativeTo(null);
initUI();
}
private void initUI() {
JTabbedPane tabs = new JTabbedPane();
tabs.add("Books", new BookPanel());
tabs.add("Members", new MemberPanel());
tabs.add("Issue/Return", new
IssuePanel());
add(tabs, BorderLayout.CENTER);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> new
MainFrame().setVisible(true));
}
}
7.8 BookPanel.java (basic Swing table + form)
import javax.swing.*;
import java.awt.*;
public class BookPanel extends JPanel {
public BookPanel() {
setLayout(new BorderLayout());
JPanel form = new JPanel(new
GridLayout(6,2,5,5));
form.add(new JLabel("ISBN:"));
form.add(new JTextField());
form.add(new JLabel("Title:"));
form.add(new JTextField());
form.add(new JLabel("Author:"));
form.add(new JTextField());
form.add(new JLabel("Publisher:"));
form.add(new JTextField());
form.add(new JLabel("Year:"));
form.add(new JTextField());
form.add(new JLabel("Copies:"));
form.add(new JTextField());
add(form, BorderLayout.NORTH);
add(new JScrollPane(new JTable()),
BorderLayout.CENTER);
}
}
9.1 Implementation notes for innovations
Barcode/QR scanning: Use a USB scanner (acts as
keyboard) or integrate webcam scanning with zxing
library.
Email notifications: Use JavaMail to schedule a daily
check for overdue issues and email members.
Import/Export: Use OpenCSV or Apache POI to parse
and write CSV/XLSX files.
10. Testing Strategy
Unit tests for DAOs (use JUnit)
Manual integration testing for GUI flows
Test data set: insert 20 books and 10 members,
issue 5 books
Test cases: issue book when copies=0, return book
late, search edge cases
10.1 Sample Test Data (SQL)
INSERT INTO books(isbn, title, author,
publisher, year, copies) VALUES
('9780140449136','The
Odyssey','Homer','Penguin',1997,3),
('9780140449181','The
Iliad','Homer','Penguin',1998,2);
INSERT INTO members(name,email,phone,address)
VALUES
('Asha Kumar','
[email protected]','+91-
9876543210','City A'),
('Ravi Sharma','
[email protected]','+91-
9123456780','City B');
11. Output Examples
Expected CLI Output after adding a book:
Book added successfully
Expected GUI Screenshots: - Book list showing entries
- Issue confirmation dialog
Placeholder images:
12. Packaging & Distribution
To distribute your app: - Create an executable JAR with
dependencies (use Maven Shade or Gradle fatJar) -
Include a README with DB setup instructions - Provide a
sample librarydb.sql for schema & sample data
Command example (Maven shade):
mvn clean package
java -jar target/library-management-1.0-
SNAPSHOT.jar
13. Step-by-step: Setting up the project (Windows)
1. Install JDK 11+ and set JAVA_HOME.
2. Install MySQL and create librarydb database.
3. Run provided schema.sql to create tables.
4. Clone project code into IDE and configure
DBConnection credentials.
5. Build and run MainFrame.
13.1 schema.sql (to include in project root)
CREATE DATABASE IF NOT EXISTS librarydb;
USE librarydb;
-- (then paste the tables DDL from Page 10)
1️⃣ BookSearch.java
Concepts Used: Arrays, Linear Search, Binary Search,
User Input
Explanation:
This program demonstrates how books can be searched
by title using both linear and binary search techniques.
import java.util.*;
public class BookSearch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] books = {"Java Basics", "Data Structures",
"Operating Systems", "Database Systems", "Computer
Networks"};
System.out.print("Enter the book title to search: ");
String title = sc.nextLine();
boolean found = false;
for (String b : books) {
if (b.equalsIgnoreCase(title)) {
found = true;
break;
}
}
System.out.println(found ? "Book found using Linear
Search!" : "Book not found.");
// Binary Search (requires sorting)
Arrays.sort(books);
int index = Arrays.binarySearch(books, title);
if (index >= 0)
System.out.println("Book found using Binary
Search!");
else
System.out.println("Book not found in Binary
Search!");
sc.close();
}
}
2️⃣ FineCalculator.java
Concepts Used: LocalDate, Period, Conditional Logic
Explanation:
This program calculates a fine for a book returned after
the due date. It uses Java’s Date and Time API for
accuracy.
import java.time.LocalDate;
import java.time.Period;
import java.util.Scanner;
public class FineCalculator {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter issue date (YYYY-MM-DD):
");
LocalDate issueDate =
LocalDate.parse(sc.nextLine());
System.out.print("Enter return date (YYYY-MM-DD):
");
LocalDate returnDate =
LocalDate.parse(sc.nextLine());
Period diff = Period.between(issueDate, returnDate);
int days = diff.getDays() + diff.getMonths() * 30;
int allowedDays = 14;
int finePerDay = 2;
int fine = (days > allowedDays) ? (days -
allowedDays) * finePerDay : 0;
System.out.println("Total days: " + days);
System.out.println("Fine amount: ₹" + fine);
sc.close();
}
}
3️⃣ UserLoginValidation.java
Concepts Used: JDBC, PreparedStatement, MySQL
Connectivity
Explanation:
This program validates a user login by checking the
username and password in a MySQL database.
import java.sql.*;
import java.util.Scanner;
public class UserLoginValidation {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter username: ");
String username = sc.nextLine();
System.out.print("Enter password: ");
String password = sc.nextLine();
try {
Connection con =
DriverManager.getConnection("jdbc:mysql://localhost:330
6/librarydb", "root", "password");
String query = "SELECT * FROM users WHERE
username=? AND password=?";
PreparedStatement pst =
con.prepareStatement(query);
pst.setString(1, username);
pst.setString(2, password);
ResultSet rs = pst.executeQuery();
if (rs.next()) {
System.out.println("Login Successful! Welcome,
" + username);
} else {
System.out.println("Invalid username or
password.");
}
con.close();
} catch (Exception e) {
System.out.println("Database connection error: "
+ e.getMessage());
}
sc.close();
}
}
4️⃣ BookSorter.java
Concepts Used: ArrayList, Comparator,
Collections.sort()
Explanation:
This program demonstrates how to sort books by title and
author using comparators.
import java.util.*;
class Book {
String title, author;
Book(String title, String author) {
this.title = title;
this.author = author;
}
}
public class BookSorter {
public static void main(String[] args) {
List<Book> books = new ArrayList<>();
books.add(new Book("Java", "James Gosling"));
books.add(new Book("C++", "Bjarne Stroustrup"));
books.add(new Book("Python", "Guido van
Rossum"));
System.out.println("Sort by Title:");
books.sort(Comparator.comparing(b -> b.title));
for (Book b : books) System.out.println(b.title + " - "
+ b.author);
System.out.println("\\nSort by Author:");
books.sort(Comparator.comparing(b -> b.author));
for (Book b : books) System.out.println(b.title + " - "
+ b.author);
}
}
5️⃣ LibraryReport.java
Concepts Used: File I/O, Looping, Exception Handling
Explanation:
This program generates a text-based library report file
listing all books.
import java.io.*;
import java.util.*;
public class LibraryReport {
public static void main(String[] args) {
List<String> books = Arrays.asList("Java
Programming", "Database Systems", "Data Structures",
"Algorithms");
try (BufferedWriter writer = new BufferedWriter(new
FileWriter("LibraryReport.txt"))) {
writer.write("---- Library Report ----\\n");
for (String b : books) {
writer.write("Book: " + b + "\\n");
}
writer.write("------------------------\\nReport
generated successfully!");
System.out.println("Report saved as
LibraryReport.txt");
} catch (IOException e) {
System.out.println("Error writing file: " +
e.getMessage());
}
}
}
6️⃣ EmailNotifier.java
Concepts Used: Classes, Loops, Method Calls (mock
email system)
Explanation:
This simple mock program simulates sending reminder
emails for overdue books.
14. Security & Validation Notes
Use prepared statements (already used) to avoid
SQL injection.
Sanitize user inputs in GUI (non-empty title, valid
email format).
For production, store DB credentials securely (not
hard-coded).
15. Extra: Export reports to CSV (example method)
public void exportBooksToCSV(String filepath)
throws IOException, SQLException {
List<Book> books = new
BookDAO().getAllBooks();
try (PrintWriter pw = new PrintWriter(new
File(filepath))) {
pw.println("ISBN,Title,Author,Publisher,Year,Cop
ies");
for (Book b : books) {
pw.printf("%s,%s,%s,%s,%d,%d\n",
b.getIsbn(), b.getTitle(), b.getAuthor(),
b.getPublisher(), b.getYear(), b.getCopies());
}
}
}
Preview image placeholder: ![CSV Preview]
16. Advanced Feature: Overdue Fine Calculation
(example)
public double calculateFine(Date dueDate, Date
returnDate) {
long diff = returnDate.getTime() -
dueDate.getTime();
long daysLate = TimeUnit.DAYS.convert(diff,
TimeUnit.MILLISECONDS);
if (daysLate <= 0) return 0.0;
double finePerDay = 5.0; // currency units
return daysLate * finePerDay;
}
17. Sample Screenshots — placeholders
.
18. Project Walkthrough (Step-by-step)
1. Create DB and tables.
2. Run DAO unit tests (optional).
3. Launch GUI via MainFrame.
4. Use the Books tab to add sample books.
5. Use Members tab to register members.
6. Use Issue/Return tab to issue a book — system
records issue and due date.
7. Return a book — system sets return date and
calculates fine if any.
19. Troubleshooting Tips
Communications link failure — check DB is
running and URL/port correct.
ClassNotFoundException:
com.mysql.cj.jdbc.Driver — add JDBC driver to
classpath.
GUI not displaying properly — ensure
SwingUtilities.invokeLater used for UI startup.
20. Project Enhancements Roadmap
Migrate to JavaFX for modern UI
Add REST API layer with Spring Boot for web/mobile
clients
Replace embedded DB with cloud DB for scalability
Add unit/integration CI using GitHub Actions
21. Use of Java — Why this language matters for the
project
Java is a versatile, high-level, object-oriented
programming language used to power applications across
billions of devices worldwide. Its primary uses span
various domains, including:
Mobile App Development
Java is the foundational language for
the Android operating system, making it the primary
choice for building Android applications. Popular apps like
Spotify, Uber, and Netflix use Java in their Android
applications or back-end services.
Enterprise Software
Due to its robustness, scalability, and security features,
Java is a dominant force in large-scale enterprise
environments. It is used to develop:
Customer Relationship Management
(CRM) and Enterprise Resource Planning
(ERP) systems.
Financial systems and trading platforms for banks
and other institutions (e.g., J.P. Morgan, Goldman
Sachs).
Supply chain management programs and billing
systems.
Web Applications and Back-End Services
Java is widely used for server-side development,
providing robust and scalable solutions for web
applications. Companies like Amazon, Google (for
services like Gmail), LinkedIn, and eBay use Java for their
back-end systems. Frameworks such as Spring, Spring
Boot, and Hibernate facilitate this development.
Big Data Technologies
Many major big data tools and frameworks are written in
or use Java. Examples include:
Apache Hadoop (a distributed file system).
Apache Kafka (a stream-processing software).
Elasticsearch and HBase (data storage and
processing tools).
Scientific and Research Applications
Java's strong mathematical capabilities, security, and
portability make it suitable for scientific and research
applications that require complex data analysis and
consistent results across platforms. An example is the
MATLAB (Mathematical Laboratory) application, which
uses Java for its user interface and core systems.
Internet of Things (IoT) Devices
The "write once, run anywhere" (WORA) principle of Java
makes it an ideal language for programming embedded
systems and small, connected devices (smart TVs, cars,
medical devices, etc.).
Desktop GUI Applications
Java can be used to build cross-platform desktop
applications with graphical user interfaces using libraries
like AWT, Swing, and JavaFX. Adobe Acrobat Reader and
the virtual globe software NASA WorldWind are real-world
examples.
Gaming Applications
Java is also used in game development, both for simple
2D and complex 3D games, especially for Android. The
immensely popular game
Minecraft
was notably built using Java.
22. Sample Output Screens (Mockups)
Mockup placeholders (replace with real screenshots
once you run the code):
23. Final Notes
This document contains full code snippets for key
components. For a complete project, implement the
omitted getters/setters and the remaining DAO
methods by following patterns shown.
Replace image placeholders with actual screenshots
from your run.
24. Appendix — Full BookDAO (complete)
// Full BookDAO including update and delete
package com.shivabrothers.library.dao;
import com.shivabrothers.library.model.Book;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class BookDAO {
public void addBook(Book book) throws
SQLException { /* as before */ }
public List<Book> getAllBooks() throws
SQLException { /* as before */ }
public void updateBook(Book book) throws
SQLException {
String sql = "UPDATE books SET
isbn=?,title=?,author=?,publisher=?,year=?,copie
s=? WHERE book_id=?";
try (Connection conn =
DBConnection.getConnection(); PreparedStatement
ps = conn.prepareStatement(sql)) {
ps.setString(1, book.getIsbn());
ps.setString(2, book.getTitle());
ps.setString(3, book.getAuthor());
ps.setString(4,
book.getPublisher());
ps.setInt(5, book.getYear());
ps.setInt(6, book.getCopies());
ps.setInt(7, book.getBookId());
ps.executeUpdate();
}
}
public void deleteBook(int bookId) throws
SQLException {
String sql = "DELETE FROM books WHERE
book_id=?";
try (Connection conn =
DBConnection.getConnection(); PreparedStatement
ps = conn.prepareStatement(sql)) {
ps.setInt(1, bookId);
ps.executeUpdate();
}
}
}
25. Checklist for Submission
☐ All Java files present in correct packages
☐ schema.sql included
☐ README with setup instructions
☐ Images folder with GUI screenshots
☐ JAR file or instructions to run from IDE
Bibliography
1. Herbert Schildt, Java: The Complete Reference.
2. Oracle Java Documentation —
https://docs.oracle.com/javase/ (replace with citation
in your final report)
3. MySQL Documentation
4. ZXing Library documentation (for QR/Barcode)
5. JavaMail API docs
End: Contact & Credits
Project by Shivamihit, Gowtham, Pranill kumar
XII-PCM
ADDITIONAL PAGES: Output, Interesting Java Points, Uses,
Preview Images, Expanded Bibliography
Output — Full Example Run (CLI)
Scenario: Add two books, register one member, issue
one book, return it late.
CLI commands & output (simulated):
> java -jar library-management.jar
Book added successfully: Effective Java (ISBN:
978-0135166307)
Book added successfully: The Odyssey (ISBN:
9780140449136)
Member registered: Asha Kumar (ID: 1)
Book issued: Issue ID 1 | Book ID 1 | Member ID
1 | Due Date: 2025-11-05
Book returned: Issue ID 1 | Return Date: 2025-
11-10 | Fine: 25.0
Explanation: The fine was calculated as 5 units per day
for 5 days late.
Preview image placeholder: 
