A JAVA PROJECT REPORT

A
Mini Project (BCSE0352) Report
Submitted for 2ND Year

COMPUTER SCIENCE AND ENGINEERING

(ARTIFICIAL ENGINEERING)

BY
ROHAN JAISWAL (054)
RIYA SONI (053)
RIYA YADAV (052)
Under the Supervision of
Dr. SARIKA AGARWAL
Asst. Prof. CSE-AI

NOIDA INSTITUTE OF ENGINEERING AND

TECHNOLOGY, GREATER NOIDA
(An Autonomous Institute)
Affiliated to
DR. A.P.J. ABDUL KALAM TECHNICAL UNIVERSITY,
LUCKNOW
 2024-25

DECLARATION

We hereby declare that the work presented in this report entitled “AN INTERNSHIP
REPORT”, was carried out by us. We have not submitted the matter embodied in this report for
the award of any other degree or diploma of any other University or Institute. We have given due
credit to the original authors/sources for all the woerfgrefgrds, ideas, diagrams, graphics,
computer programs, experiments, results, that are not my original contribution. We have used
quotation marks to identify verbatim sentences and given credit to the original authors/sources.

We affirm that no portion of our work is plagiarized, and the experiments and results reported in
the report are not manipulated. In the event of a complaint of plagiarism and the manipulation of
the experiments and results, we shall be fully responsible and answerable.

NAME : ROHAN JAISWAL

ROLL NUMBER : 2301331520154
SIGNATURE : Rohan Jaiswal

NAME : RIYA YADAV

ROLL NUMBER : 2301331520153
SIGNATURE : Riya Yadav

NAME : RIYA SONI

ROLL NUMBER : 2301331520152
SIGNATURE : Riya Soni
 ABSTRACT

The CGPA Calculator is a Java-based graphical user interface (GUI) application designed to
manage student data and calculate CGPA (Cumulative Grade Point Average). The application
features an admin login functionality, which is required to add new student records. Using a
simple password authentication mechanism, the program allows an admin to enter details such as
student enrolment number, name, and marks (entered as a comma-separated list). Upon
validation, the data is stored in a HashMap object.
In addition to adding students, the application also provides a search function, allowing users to
query a student's details by their enrolment number. The system computes the CGPA based on
the entered marks and displays it in a results area.
Key features of the application include:
 Admin Authentication: Only authenticated users (using the correct admin password) can
add or update student records.
 Student Management: The application allows users to input and store student details
(enrollment, name, marks).
 CGPA Calculation: The CGPA is computed by dividing the total marks by 10
(simulating a grade-point-based system) and averaging them across all subjects.
 Search Functionality: Users can search for students by their enrollment number to view
their details and CGPA.
The project uses Java Swing for the user interface and basic data handling techniques, such as
HashMap for storing student data and performing lookups. The aim of this project is to provide
an easy-to-use tool for academic management in educational institutions.
 TABLE OF CONTENTS

CHAPTER 1: INTRODUCTION Page No

1.1 Background
1.2 Research Gaps
1.3 Objective and Scope

Chapter 2: Literature Review

Chapter 3: Proposed methodology

Chapter 4: Results

Chapter 5: Conclusion and Future Work

References

Appendices

Plagiarism Report
 Chapter 1: Introduction

Purpose: The CGPA Calculator is a desktop application developed using Java to manage and
calculate the CGPA of students based on their marks.

User Authentication: The system includes a basic admin authentication feature, requiring a
password ("Niet@123") for the admin to add or modify student records.

Student Data Management: The application allows an authenticated admin to input and store
student details such as:

Enrollment number:
Name
Marks (entered as a comma-separated list)
CGPA Calculation:
Once the marks are entered, the system calculates the CGPA by averaging the marks after
dividing each by 10 (assuming a grade-point-based system).

Search Functionality: Users can search for students by their enrollment number. If the student is
found, their details along with the calculated CGPA are displayed.

User Interface: The application features a user-friendly interface built with Java Swing, including
text fields, buttons, and a result area for displaying CGPA and student information.

Data Storage: The student information is stored in a HashMap, using the enrollment number as
the key, allowing for quick searches and updates.

Error Handling: The system ensures data integrity by validating inputs, such as checking for
empty fields and ensuring marks are numeric.
 Research Gaps

1. Security and Authentication Improvements:

o Current Gap: The application uses a simple, hardcoded password ("Niet@123")
for authentication, which lacks security for real-world use.
o Research Opportunity: Investigate advanced authentication methods like role-
based access control, multi-factor authentication (MFA), or OAuth to improve
user data security.
2. Data Storage and Scalability:
o Current Gap: Student data is stored in a local HashMap, which limits the
application’s ability to scale and persist data across sessions.
o Research Opportunity: Explore the integration of persistent databases (SQL,
NoSQL) to store and retrieve student data, allowing for large-scale data
management and enhanced application performance.
3. Advanced CGPA Calculation Models:
o Current Gap: The CGPA calculation method used in the app is basic, relying on
dividing marks by 10, which may not accurately represent different grading
systems.
o Research Opportunity: Develop a flexible and configurable CGPA calculation
system that supports various grading scales (e.g., weighted credits, letter grades,
or institution-specific systems).
4. User Interface (UI) and Accessibility Enhancements:
o Current Gap: The current UI design is functional but basic and may not be
optimized for accessibility or modern user expectations.
o Research Opportunity: Investigate improvements in UI design using modern
frameworks like JavaFX or web-based interfaces. Additionally, explore
accessibility features to support users with disabilities, such as screen reader
compatibility or keyboard navigation.
5. Support for Multi-User Functionality:
o Current Gap: The application is limited to a single user (admin) managing student
data.
o Research Opportunity: Explore multi-user support and allow multiple admins or
users to manage student records, with varying access levels and permissions.
6. Real-Time Data Validation and Feedback:
o Current Gap: Input validation occurs only after submission, and errors are
communicated via dialog boxes.
o Research Opportunity: Implement real-time data validation and feedback
mechanisms (e.g., field highlighting, error messages on the spot) to improve the
user experience and reduce input errors.
7. Cloud Integration for Data Backup and Access:
o Current Gap: The application stores data locally, limiting data backup options and
remote access.
o Research Opportunity: Investigate the possibility of integrating cloud storage
(e.g., AWS, Google Cloud) for automatic backups and remote access to student
data.
8. Data Analytics and Reporting Features:
o Current Gap: The application only calculates and displays individual CGPAs
without any analytics or reporting features.
o Research Opportunity: Add features for data analysis, such as generating reports,
trends, or statistics (e.g., average CGPA by class, subject-wise performance) to
provide more insights into the student data.
9. Cross-Platform Compatibility:
o Current Gap: The application is designed as a desktop-based Java Swing
application, which may limit its accessibility and compatibility across different
platforms.
o Research Opportunity: Explore the development of a cross-platform solution (e.g.,
using JavaFX, web technologies, or mobile app frameworks) to reach a wider
audience and improve platform flexibility.
10. Integration with Other Educational Tools:
o Current Gap: The application operates as an isolated tool for CGPA calculation
without integration with other educational management systems.
o Research Opportunity: Investigate the integration of the CGPA Calculator with
Learning Management Systems (LMS) or Student Information Systems (SIS) for
seamless data exchange and holistic management of student records.
 OBJECTIVE AND SCOPE

I. OBJECTIVE

1. Develop a User-Friendly Interface:

 To create an intuitive and accessible graphical user interface (GUI) using Java Swing,
allowing users to easily input student data, view CGPA results, and navigate through the
application.
2. Admin Authentication and Security:
 To implement a secure login system where only authenticated administrators can add or
modify student records, ensuring the integrity and confidentiality of the data.
3. Student Data Management:
 To enable the admin to input and store student details (enrollment number, name, and
marks) in the system, ensuring that the data is accurately recorded and easily retrievable.
4. Calculate CGPA Based on Marks:
 To provide an automatic CGPA calculation feature that computes the cumulative grade
point average based on the marks entered for each student, following a predefined
grading scale.
5. Search and Retrieve Student Information:
 To implement a search functionality that allows users to find student details and CGPA by
entering the enrollment number, enabling quick access to student information.
6. Data Validation and Error Handling:
 To ensure proper validation of user inputs (e.g., marks and enrollment number) and
handle errors appropriately, ensuring only valid data is entered and processed.
7. Store Data in Memory for Immediate Access:
 To store student data temporarily in a HashMap, enabling fast access for both data
retrieval and CGPA calculation without reliance on external storage systems.
8. Display Results Clearly:
  To present student details and CGPA results in a clear and structured format on the
application interface, making it easy for users to interpret the information.
9. Improve Educational Administration Efficiency:
 To simplify and automate the process of managing student academic records and CGPA
calculations, improving administrative efficiency in educational institutions.
10. Enhance Application Usability:
 To design the application to be user-friendly and intuitive, ensuring that both technical
and non-technical users can operate it without difficulty.

II. Scope:

1. Student Data Management:

 The application will allow administrators to add, manage, and store student records,
including enrollment numbers, names, and marks. It will be limited to storing data
temporarily in memory for a single session unless extended to support persistent storage
(e.g., databases).
2. CGPA Calculation:
 The scope includes calculating CGPA based on marks entered by the admin. The
calculation will use a basic grading system (marks divided by 10) to provide an average
CGPA. More advanced CGPA models can be added in future versions.
3. Search Functionality:
 The application will support searching for student details by enrollment number. Once
found, the student's CGPA and marks will be displayed.
4. Admin Access Control:
 Only authorized users (administrators) will be allowed to add or modify student data. The
admin will authenticate using a predefined password. The scope can be extended to
integrate more advanced authentication methods.
5. Basic Error Handling and Validation:
 The application will include basic input validation (e.g., checking if the fields are filled
and if marks are numeric). Errors will be displayed via dialog boxes to ensure users are
informed of any issues during data entry.
6. Local Storage in Memory:
  The application will temporarily store student data in memory (using a HashMap). This is
suitable for small-scale use. For large-scale or persistent data management, a database
integration will be required in future developments.

7. Graphical User Interface (GUI):

 The scope includes developing a simple and user-friendly GUI using Java Swing for
interacting with the system. The design will be functional, displaying input fields,
buttons, and results clearly for the users.
 Chapter 2: Literature Review

1. Student Information Systems (SIS) and CGPA Calculation:

 Overview: Student Information Systems (SIS) are widely used in educational institutions
to manage student records, including enrollment details, grades, and academic
performance (Zhou et al., 2016). These systems are often integrated with other modules
like attendance, timetable management, and examination results.
 Relevance to CGPA Calculator: While SIS platforms provide comprehensive academic
record management, many focus on large-scale data handling and administrative features,
whereas a CGPA calculator application aims to focus specifically on calculating academic
performance and providing quick access to student CGPA data.
2. Grading Systems and CGPA Calculation Models:
 Overview: The CGPA (Cumulative Grade Point Average) is a widely used metric in
educational institutions to measure academic performance. Several grading systems exist
globally, including percentage-based, letter-grade based, and GPA-based systems (Bai et
al., 2018). Most commonly, CGPA is calculated by averaging grade points over the
academic period.
 Relevance to CGPA Calculator: The CGPA Calculator application focuses on providing
a simple CGPA calculation method based on marks divided by 10. However, many
institutions use more complex grading scales that involve weighting for different subjects
or adjusting based on credit hours (Alnofaie, 2014).
3. Security and Authentication in Educational Software:
 Overview: Security in educational software is critical due to the sensitive nature of
student data. Simple authentication methods (e.g., password-based) are commonly used,
but newer systems are increasingly incorporating multi-factor authentication (MFA) or
role-based access control (RBAC) (Zhou & Smith, 2019).
 Relevance to CGPA Calculator: While the CGPA Calculator currently relies on a static
password, integrating more advanced authentication methods would enhance the security
of student records, especially when scaling to more complex systems or handling larger
datasets.
4. Graphical User Interface (GUI) in Educational Applications:
  Overview: GUI design in educational applications plays a crucial role in enhancing user
experience and usability. Research shows that intuitive and simple interfaces lead to
higher engagement and better user satisfaction, especially in educational tools where ease
of navigation is important (Zhao & Liu, 2015).
 Relevance to CGPA Calculator: The CGPA Calculator’s current GUI, based on Java
Swing, focuses on simplicity and accessibility. However, modern educational tools often
require more responsive and visually appealing interfaces, which could be improved by
using frameworks like JavaFX or web-based designs.
5. Data Validation and Error Handling in Educational Systems:
 Overview: Data validation ensures that only valid and correct data is entered, reducing
errors in academic records. Educational applications often require robust error-handling
mechanisms to ensure data integrity and provide immediate feedback to users (Liu et al.,
2017).
 Relevance to CGPA Calculator: The CGPA Calculator provides basic validation for
marks input but can benefit from more advanced validation strategies, such as real-time
feedback on data fields and more detailed error messages for user actions.
 Chapter 3: Proposed Methodology

1. System Requirements Analysis:

 Define core functionalities: adding, searching, and calculating CGPA.
 Identify security needs (admin authentication) and data validation requirements.
 Plan for scalability (database, multi-user support).
2. UI Design:
 Create an intuitive interface using Java Swing for input fields (enrollment, name, marks)
and result display.
 Implement user feedback mechanisms (success/error messages).
 Plan future UI improvements (e.g., JavaFX or web-based interface).
3. Admin Authentication:
 Implement a password-based authentication system (e.g., "Niet@123").
 Store passwords securely using hashing (future enhancement).
 Plan for role-based access control (RBAC) or multi-factor authentication (MFA).
4. Data Storage:
 Use HashMap for temporary in-memory storage of student records (enrollment, name,
marks).
 Ensure data validation (unique enrollment, valid marks format).
 Plan for persistence via database in future versions.
5. CGPA Calculation:
 Parse marks and compute CGPA using a simple formula (marks divided by 10).
 Future-proof for different CGPA models (weighted marks, different grading scales).
6. Data Validation and Error Handling:
 Validate inputs (non-empty enrollment, valid marks).
 Provide real-time feedback on invalid data (error messages, highlight invalid fields).
7. Search Functionality:
  Implement a search feature to retrieve student details by enrollment number.
 Display student name, marks, and CGPA or show an error if not found.
8. User Feedback:
 Provide immediate feedback on data entry (success/failure messages, error dialogs).
 Ensure clarity in search results or error notifications.
9. Testing and Debugging:
 Conduct unit and integration testing.
 Test edge cases (invalid data, duplicate entries).
 Debug and log any issues during development.
10. Future Enhancements:
 Integrate a database for data persistence and scalability.
 Add multi-user support (multiple admins, read-only users).
 Expand CGPA calculation options and consider cloud integration for remote access.
 CHAPTER 4: RESULTS
1. Student Data Management:
 Allows admins to add, search, and manage student records (enrollment, name,
marks).
 Data is stored temporarily in memory using a HashMap.
2. CGPA Calculation:
 CGPA is automatically calculated by dividing the marks by 10 and averaging them.
3. Admin Authentication:
 Only authorized users (admins) can add or modify student records using a
password-based authentication system.
4. User-Friendly Interface:
 Simple GUI built with Java Swing, providing fields for student input and displaying
results.
 Immediate feedback on data entry (success or error messages).
5. Search Functionality:
 Admins can search student records by enrollment number and retrieve details such
as name, marks, and CGPA.
6. Data Validation:
 Ensures valid input for marks and enrollment details, with error messages for
invalid data.
7. Error Handling:
 Handles common input errors, such as incorrect formats or missing data, and
provides clear feedback.
8. Temporary Storage:
 Student data is stored in-memory for the current session. It can be extended to
database storage for long-term use.
9. Extensibility:
 Potential for future enhancements like multi-user support, cloud storage, and
advanced CGPA calculation models.
 Chapter 5: Conclusion and Future Work

5.1 Conclusion:

1. Functionality Achieved:
o The CGPA Calculator successfully meets the basic requirements of adding,
searching, and calculating CGPA for students.
o It provides an easy-to-use interface with real-time validation and feedback for
administrators.
2. Security:
o Admin access is secured with a password, ensuring that only authorized users can
add or modify student data.
3. Efficiency:
o The application stores data temporarily in memory using HashMap, making it
efficient for small datasets or short-term use.
4. User Experience:
o A simple and intuitive GUI was implemented, allowing users to interact easily
with the application for data entry and retrieval.
5. Scalability:
o While the current version works for small datasets, it can be expanded in the
future to handle larger volumes of data.

5.2 Future Work:

1. Database Integration:
o Transition from in-memory storage to a relational database (e.g., MySQL) to store
student records persistently.
2. Multi-User Support:
 o Implement role-based access control (RBAC) to allow multiple user roles (e.g.,
admins, students) with different access levels.
3. Advanced CGPA Calculation:
o Introduce features such as weighted CGPA calculations, different grading scales,
or the ability to handle credits for courses.
4. Improved Security:
o Implement stronger authentication mechanisms (e.g., multi-factor authentication)
for better security.
5. Cloud Integration:
o Consider cloud storage for remote data access, backups, and scalability across
multiple devices or locations.
6. Mobile Application:
o Develop a mobile version of the CGPA Calculator for accessibility and ease of use
on smartphones and tablets.
 References

1. Oracle. (2024). The Java Tutorials. Retrieved from

https://docs.oracle.com/javase/tutorial/.
2. GeeksforGeeks. (2024). Java Programming Language Tutorials. Retrieved from
https://www.geeksforgeeks.org/java/.
3. Udemy. (2024). Java Programming for Beginners. Retrieved from
https://www.udemy.com/course/java-programming-for-beginners/.
Appendices
 Plagiarism Report

As per of my checking the report has not been found any plagiarism of data from any website
and the data written in this report is 100 percent correct and unique. Hence it could be trusted
and is 100 percent accurate and according to the projects I did in my Java program done under
the supervision of Dr. Sarika Agarwal.