GRADE MARKING SYSTEM IN JAVA

A CAPSTONE PROJECT
Submitted By

KOLLU VENKATA SAI

192211307

In Partial Fulfillment for the completion of the course

CSA0969
PROGRAMMING IN JAVA FOR ARCHITECTURE NEURAL NETWORK PLATFORM
SEPTEMBER 2024

SAVEETHA INSTITUTE OF MEDICAL AND TECHNICAL

SCIENCES
CHENNAI - 602105
TAMIL NADU, INDIA
 BONAFIDE CERTIFICATE

This is to certify that the project report entitled GRADE MAKING SYSTEM IN JAVA

submitted by KOLLU VENKATA SAI - 192211307, to Saveetha School of Engineering,

Saveetha Institute of Medical and Technical Sciences, Chennai, is a record of bonafide work

carried out by him/her under my guidance. The project fulfills the requirements as per the

regulations of this institution and in my appraisal meets the required standards for

submission.

GODWIN S
COURSE FACULTY
Department of Deep Learning.
Saveetha School of Engineering,
SIMATS, Chennai - 602105

1
 ACKNOWLEDGEMENT

This project work would not have been possible without the contribution of many

people. It gives me immense pleasure to express my profound gratitude to our Honorable

Chancellor Dr. N M VEERAIYAN, Saveetha Institute of Medical and Technical Sciences, for his

blessings and for being a source of inspiration. I sincerely thank our Director of Academics

Dr. DEEPAK NALLASWAMY, SIMATS, for his visionary thoughts and support. I am indebted

to extend my gratitude to our Director Dr. RAMYA DEEPAK, Saveetha School of Engineering,

for facilitating us with all the facilities and extended support to gain valuable education and

learning experience.

I register my special thanks to Dr. B RAMESH, Principal, Saveetha School of Engineering

for the support given to me in the successful conduct of this project. I wish to express my

sincere gratitude to my Course faculty S GODWIN, for his inspiring guidance, personal

involvement and constant encouragement during the entire course of this work.

I am grateful to Project Coordinators, Review Panel External and Internal Members and

the entire faculty of the Department of Design, for their constructive criticisms and valuable

suggestions which have been a rich source to improve the quality of this work.

INDEX

2
BONAFIDE CERTIFICATE.............................................................................................................................................................

ACKNOWLEDGEMENT..................................................................................................................................................................

1. ABSTRACT....................................................................................................................................................................................

2. INTRODUCTION.........................................................................................................................................................................

3. ARCHITECTURE DIAGRAM......................................................................................................................................................

4. FLOWCHART...............................................................................................................................................................................

5. UML DIAGRAM...........................................................................................................................................................................

6. CLASS DIAGRAM........................................................................................................................................................................

7. CODE IMPLEMENTATION........................................................................................................................................................

7.1 JAVA CODE...........................................................................................................................................................................

7.2 HTML CODE........................................................................................................................................................................

7.3 CSS CODE.............................................................................................................................................................................

8. OUTPUT SCREENSHOT.............................................................................................................................................................

9. CONCLUSION...............................................................................................................................................................................

10. REFERENCES.............................................................................................................................................................................

3
 1. ABSTRACT

The Grade Marking System is a Java-based application designed to streamline the process of

evaluating and recording student performance. This system automates the calculation and

management of student grades, offering a user-friendly interface for educators and

administrative staff. The core functionality includes the ability to input student data, assign

grades for various assignments and exams, compute final grades based on weighted criteria,

and generate comprehensive reports. The Grade Marking System aims to enhance the

efficiency of academic administration by reducing manual calculations, minimizing errors,

and providing timely access to performance data. It supports various educational institutions

by adapting to different grading schemes and reporting requirements, making it a versatile

tool for modern educational environments.

4
 2. INTRODUCTION

The Grade Marking System utilizes Java, a powerful and versatile programming language, to
create a user-friendly application that caters to the needs of educational institutions. Java's
object-oriented capabilities allow for the development of a modular system that is both
scalable and maintainable. By leveraging Java's extensive libraries and frameworks, the system
integrates essential functionalities that simplify grade entry, calculation, and reporting
processes.

At its core, the system features a comprehensive student management module. This
component allows administrators and educators to efficiently handle student data, including
personal information and academic history. By providing an organized database of student
records, the system ensures that all relevant information is readily accessible, facilitating
smoother operations and communication within educational institutions.

The grade entry and calculation module is designed to automate the assessment process.
Educators can input grades for various assignments, quizzes, and exams, with the system
applying predefined weightings to compute final grades. This automation not only reduces the
risk of human error but also accelerates the grading process, enabling timely feedback for
students and allowing educators to focus on teaching rather than administrative tasks.

In addition to grade management, the system includes advanced reporting capabilities. It

generates detailed reports and transcripts that can be customized and exported in various
formats, such as PDF or CSV. These reports provide valuable insights into student performance
and academic progress, supporting both administrative decision-making and parent-teacher
communications.

The user interface of the Grade Marking System is designed with simplicity and ease of use in
mind. Utilizing Java’s graphical user interface (GUI) frameworks, such as Swing or JavaFX, the
system offers an intuitive and interactive experience. This ensures that users, regardless of
their technical expertise, can navigate the application efficiently and perform necessary tasks
with minimal training.

In contemporary education, the accurate and efficient management of student grades is a

fundamental requirement for academic institutions. Traditional grading methods, which often
rely on manual calculations and record-keeping, can be cumbersome and prone to errors. To
address these issues, the Grade Marking System developed in Java offers a modern solution
that automates and streamlines the grading process, significantly enhancing administrative
efficiency and accuracy.

uilt using Java, a robust and versatile programming language, the Grade Marking System
incorporates key features designed to simplify grade management. The system includes
modules for student record management, grade entry, calculation, and comprehensive
reporting. By automating these processes, the system minimizes the potential for human

5
error, accelerates the grading workflow, and provides detailed insights into student
performance. This automation allows educators to spend more time on teaching and less on
administrative tasks. Overall, the Grade Marking System in Java represents a significant
advancement in the way educational institutions manage student grades. By automating
repetitive tasks, providing detailed reports, and offering a user-friendly interface, the system
enhances the overall efficiency of academic administration. Its adaptability to various grading
schemes and reporting requirements makes it a valuable tool for institutions seeking to
modernize their grading processes and improve educational outcomes.

6
 3. ARCHITECTURE DIAGRAM

Figure 3.1 : Architecture Diagram

An architecture diagram for a Grade Marking System in Java provides a visual representation
of the system's structure and how its various components interact. It illustrates the
organization of the software into different layers and modules, highlighting the flow of data
and responsibilities among components. Here’s a detailed breakdown of what the
architecture diagram typically shows:

● Component Overview: This layer is responsible for interacting with users. It includes
all visual components that users interact with, such as forms for data entry, tables for
displaying grades, and reports for academic progress.
● Application Layer: This layer serves as the intermediary between the presentation
layer and the business logic layer.
● Presentation Layer: This layer includes the user interface components built with
HTML, CSS, and JavaScript. It handles user interactions.
● Business Logic Layer: Implemented in Java, this layer processes the currency
conversion logic.
● Data Layer: Manages data persistence and retrieval. It provides an abstraction for
interacting with the database.

● Communication: The layers interact with each other using defined protocols,
ensuring modularity and maintainability.

This diagram delineates its modular structure, emphasizing the separation of concerns to
ensure maintainability and scalability. The system is divided into three primary layers: the

7
Presentation Layer, the Business Logic Layer, and the Data Layer.

The Application Layer in a Grade Marking System in Java plays a critical role in managing the
interactions between the user interface (UI) and the underlying business logic.It acts as an
intermediary that handles user requests, coordinates the execution of business rules, and
facilitates communication between different layers of the system.

The Business Logic Layer (or Business Layer) in a Grade Marking System in Java is
fundamental to the application’s core functionality. It contains the logic and rules that
govern how grades are calculated, how student data is managed, and how various operations
are performed. This layer ensures that the system operates according to the business rules
and requirements set forth by the educational institution

The Data Layer (or Data Access Layer) in a Grade Marking System in Java is crucial for
managing the persistence of data. It handles all interactions with the database or any data
storage system, providing an abstraction that separates data access from the rest of the
application.

8
 4. FLOWCHART

Figure 4.1 : Flowchart

The flowchart for the grade marking system in java depicts the step-by-step process from

9
user input to the final conversion result.

● Start: The process begins when the user accesses the name and his/her roll number.
● Input: User inputs the marks for different subjects
● Validation: The system checks all the fields are attempted or not.
● Fetch Rates: refers to retrieving data such as grade distributions, average grades, or
performance metrics from the database or application for analysis and reporting.
● Calculation: The conversion is performed using the fetched exchange rate.
● Display Result: The total and average is displayed successfully.
● End: The process completes, and the user can perform another conversion.

The Simple Grading System flowchart template outlines a straightforward grading system.
The flowchart includes actions such as obtaining a score, determining the score range, and
identifying whether the student has passed or failed. The flowchart begins with the start
symbol and proceeds to the action of obtaining a score. The flowchart then checks if the
score is within the valid range of 0 to 100.

If the score is equal to or greater than 80, the flowchart indicates that the student has
achieved a high score. If the score is between 60 and 79, the flowchart suggests that the
student has achieved a passing grade. If the score is between 50 and 59, the flowchart
indicates that the student has failed.

The flowchart concludes with the "Fail" outcome, indicating that any score below 50 results
in a failing grade rates. This flowchart provides a visual representation of the sequential
steps involved in determining the grade based on a given score.

The calculated result is then displayed to the user, providing immediate feedback. The user
can view the converted result and, if necessary, perform another conversion by entering new
marks. The process ensures a smooth and efficient flow from input to output, making the
application user-friendly and reliable.

10
 5. UML DIAGRAM

Figure 5.1 : UML Diagram

UML (Unified Modeling Language) diagrams are valuable tools for designing, documenting,
and understanding a Grade Marking System in Java.

● Classes: Displays classes like Student, Grade, Course, and their relationships, such as
associations and inheritances.
● Component Diagram: Shows the system's components and their dependencies,
aiding in understanding the system's modular structure.
● Sequence Diagram: Depicts the sequence of messages exchanged between objects to
carry out a specific function or process.
● Collaboration Diagram: Emphasizes the interactions between objects and how they
collaborate to achieve a specific outcome.
● Relationships: These relationships help in organizing, managing, and efficiently
processing information.

UML (Unified Modeling Language) diagrams provide a comprehensive visual representation

of a Grade Marking System in Java, illustrating its structure, behavior, and interactions. They
serve as crucial tools for understanding and designing the system’s components and their
relationships.

Sequence diagrams show the order of interactions between objects, such as the process of
entering grades where the UI interacts with GradeService and GradeDAO. Activity diagrams
illustrate the workflows, such as the process for generating a grade report, including all the

11
steps involved from data entry to report generation.

Finally, use case diagrams capture the functional requirements and interactions between
users and the system. They illustrate various use cases like "Add Student," "Enter Grades,"
and "Generate Report," along with the actors (e.g., teachers, students) who interact with
these functions. This high-level view helps in identifying the main functionalities of the
system and how different user roles engage with the system’s features.

6. CLASS DIAGRAM

Figure 6.1 : Class Diagram

● In a Grade Marking System in Java, a class diagram provides a detailed visual

representation of the system's static structure. It illustrates the various classes
involved, their attributes, methods, and the relationships between these classes.
● Classes and Their Attributes: Each class represents a blueprint for objects in the
system, encapsulating data and behavior.
● Relationships Between Classes: Shows how classes are related and interact with each
other.
● Methods and Operations: Methods like calculateFinalGrade() to compute the final
grade based on various assignments, and printGradeReport() to generate a report of
grades.

A class diagram provides a clear and organized view of the system's structure, defining the
various classes and their relationships. In a Grade Marking System, this includes classes like
Student, Grade, Course, and Report. By depicting the attributes and methods of each class,

12
along with their interactions, the class diagram helps developers understand how different
components of the system are structured and how they collaborate to fulfill the system’s
requirements. This foundational design helps in creating a robust architecture that ensures
all necessary functionality is covered and that components are well-organized.

During the coding phase, a class diagram serves as a blueprint for developers, guiding the
implementation of classes and their interactions. It helps developers maintain consistency
and adhere to the design specifications by providing a visual representation of the class
structure and relationships.

For instance, knowing that a Student class has a one-to-many relationship with a Grade
class allows developers to correctly implement the necessary methods and attributes to
manage this relationship. This organization facilitates a more coherent and manageable
codebase, reducing the risk of errors and inconsistencies.

Class diagrams act as a common language for communicating design ideas among
stakeholders, including developers, designers, and project managers. They offer a visual
representation that is easier to understand than textual descriptions, making it simpler to
discuss and review the system’s design.

For instance, when explaining the interaction between the Student and Course classes, the
diagram helps stakeholders visualize how students enroll in courses and how this
relationship is managed within the system. This clarity improves collaborative efforts and
ensures that all parties have a shared understanding of the system’s design.

13
 7. CODE IMPLEMENTATION

7.1 JAVA CODE

function generateResult() {
const name = document.getElementById('name').value;
const regNo = document.getElementById('regNo').value;

const subjects = [
{ name: document.getElementById('subjectName1').value, marks:
Number(document.getElementById('subjectMarks1').value) },
{ name: document.getElementById('subjectName2').value, marks:
Number(document.getElementById('subjectMarks2').value) },
{ name: document.getElementById('subjectName3').value, marks:
Number(document.getElementById('subjectMarks3').value) },
{ name: document.getElementById('subjectName4').value, marks:
Number(document.getElementById('subjectMarks4').value) },
{ name: document.getElementById('subjectName5').value, marks:
Number(document.getElementById('subjectMarks5').value) }
];

let total = 0;
let hasFail = false; // Track if any subject has failed
let resultText = Saveetha School of Engineering\n\nName: ${name}\nRegister Number: $
{regNo}\n\nResults:\n;

const resultHTML = subjects.map(subject => {

if (subject.marks < 50) {
hasFail = true; // Mark as fail if any subject has less than 50 marks
}
total += subject.marks;
return <span>${subject.name}: ${subject.marks} - ${subject.marks < 50 ? 'Fail' :
'Pass'}</span><br>;
}).join('');

const average = total / subjects.length;

let grade;
if (hasFail) {
grade = 'Fail'; // If any subject has failed, the grade is 'Fail'
} else if (average >= 90) {
grade = 'A';
} else if (average >= 80) {

14
 grade = 'B';
} else if (average >= 70) {
grade = 'C';
} else if (average >= 50) {
grade = 'D';
} else {
grade = 'Fail';
}

resultText += resultHTML + <br>Total: ${total}\nAverage: ${average.toFixed(2)}\nGrade: $

{grade};

document.getElementById('resultText').innerHTML = <strong>Saveetha School of

Engineering</strong><br><br> +
Name: ${name}<br>Register Number: ${regNo}<br><br> + resultHTML + <br>Total: $
{total}<br>Average: ${average.toFixed(2)}<br>Grade: ${grade};

document.getElementById('result').classList.remove('hidden');
}

function downloadPDF() {
const { jsPDF } = window.jspdf;
const doc = new jsPDF();

const name = document.getElementById('name').value;

const regNo = document.getElementById('regNo').value;
const resultText = document.getElementById('resultText').innerText;

// Add title
doc.setFontSize(16);
doc.text('Saveetha School of Engineering', 10, 10);

// Add student details

doc.setFontSize(12);
doc.text(Name: ${name}, 10, 20);
doc.text(Register Number: ${regNo}, 10, 30);

// Add result details

doc.text(resultText, 10, 40);

// Save the PDF

doc.save('result.pdf');
}

15
7.2 HTML CODE

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Saveetha Grade Marking System</title>
<link rel="stylesheet" href="styles.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/jspdf/2.5.1/jspdf.umd.min.js"></script>
</head>
<body>
<div class="container">
<h1>Saveetha Grade Marking System</h1>
<form id="gradeForm">
<label for="name">Name:</label>
<input type="text" id="name" name="name" class="input-field" required>

<label for="regNo">Register Number:</label>

<input type="text" id="regNo" name="regNo" class="input-field" required>

<div id="subjects">
<div class="subject-entry">
<label for="subjectName1">Subject 1 Name:</label>
<input type="text" id="subjectName1" name="subjectName1" class="subject-name"
required>
<label for="subjectMarks1">Subject 1 Marks:</label>
<input type="number" id="subjectMarks1" name="subjectMarks1" class="subject-marks"
required>
</div>
<div class="subject-entry">
<label for="subjectName2">Subject 2 Name:</label>
<input type="text" id="subjectName2" name="subjectName2" class="subject-name"
required>
<label for="subjectMarks2">Subject 2 Marks:</label>
<input type="number" id="subjectMarks2" name="subjectMarks2" class="subject-marks"
required>
</div>
<div class="subject-entry">
<label for="subjectName3">Subject 3 Name:</label>
<input type="text" id="subjectName3" name="subjectName3" class="subject-name"
required>

16
<label for="subjectMarks3">Subject 3 Marks:</label>
<input type="number" id="subjectMarks3" name="subjectMarks3" class="subject-marks"
required>
</div>
<div class="subject-entry">
<label for="subjectName4">Subject 4 Name:</label>
<input type="text" id="subjectName4" name="subjectName4" class="subject-name"
required>
<label for="subjectMarks4">Subject 4 Marks:</label>
<input type="number" id="subjectMarks4" name="subjectMarks4" class="subject-marks"
required>
</div>
<div class="subject-entry">
<label for="subjectName5">Subject 5 Name:</label>
<input type="text" id="subjectName5" name="subjectName5" class="subject-name"
required>
<label for="subjectMarks5">Subject 5 Marks:</label>
<input type="number" id="subjectMarks5" name="subjectMarks5" class="subject-marks"
required>
</div>
</div>

<button type="button" onclick="generateResult()">Generate Result</button>

</form>

<div id="result" class="hidden">

<h2>Result</h2>
<p id="resultText"></p>
<button onclick="downloadPDF()">Download as PDF</button>
</div>
</div>

<script src="script.js"></script>
</body>
</html>

17
7.3 CSS CODE

body {
font-family: 'Arial', sans-serif;
background-color: #f0f4f7;
display: flex;
justify-content: center;
align-items: center;
height: 100vh;
margin: 0;
}

.container {
background-color: #ffffff;
padding: 30px;
border-radius: 10px;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
width: 90%;
max-width: 800px;
border: 2px solid #00796b;
}

h1 {
color: #00796b;
text-align: center;
margin-bottom: 20px;
}

label {
display: block;
margin: 10px 0 5px;
color: #00796b;
font-weight: bold;
}

.input-field {
width: calc(100% - 24px);
padding: 12px;
margin-bottom: 10px;
border: 1px solid #00796b;
border-radius: 6px;
font-size: 16px;
}

18
.subject-name {
background-color: #e0f2f1; /* Light teal */
}

.subject-marks {
background-color: #c8e6c9; /* Light green */
}

.subject-entry {
display: flex;
flex-direction: column;
margin-bottom: 20px;
}

button {
background-color: #00796b;
color: white;
border: none;
padding: 12px 20px;
border-radius: 6px;
cursor: pointer;
font-size: 16px;
}

button:hover {
background-color: #004d40;
}

.hidden {
display: none;
}

#result {
margin-top: 20px;
padding: 20px;
background-color: #e8f5e9;
border: 1px solid #00796b;
border-radius: 6px;
}

#resultText {
margin-bottom: 10px;
font-size: 16px;
}

19
8. OUTPUT SCREENSHOT

Figure 8.1 Fill the details.

20
Figure 8.2 : Enter subject name and marks

Figure 8.3 : Click on generate result.

21
Figure 8.4 : Result will be generated.

22
 Figure 8.5 : Click on generate pdf.

Figure 8.6 : We can see that total and average will be displayed

9. CONCLUSION

This capstone project successfully developed a grade marking system application using Java,

The system collects student data, including personal details (e.g., name, registration number)

and academic performance (e.g., marks in various subjects).

Input can be handled via user interfaces (like Swing, JavaFX) or command-line interfaces,

depending on the application's complexity and requirements.

23
The core logic involves calculating total marks, average, and determining the grade based on

predefined criteria.

24
 10. REFERENCES

[1] M. Armoni, O. Meerbaum-Salant, M. Ben-Ari, “From scratch to“ real

”programming[J],” ACM Trans. Comp. Edu. (TOCE), vol. 14, no. 4, pp. 1-15,

2015, doi:10.1145/2677087.

[2] D. Herron, Node.js Web Development[M], Packt Pub., 2018.

[3] X. Lu, N. Funabiki, S. T. Aung, H. H. S. Kyaw, K. Ueda, and W-C. Kao, “A study of

grammar-concept understanding problem in C programming learning assistant

system[J],” ITE Trans. Media Tech. Appl., vol. 10, no. 4, pp. 198-207, 2022,

doi:10.3169/mta.10.198.

[4] X. Lu, N. Funabiki, H. H. S. Kyaw, E. E. Htet, S. L. Aung, and N. K. Dim, “Value trace

problems for code reading study in C programming[J],” Adv. Sci. Tech. Eng. Syst. J.

(ASTESJ), vol. 7, no. 1, pp. 14-26, 2022, doi:10.25046/aj070103.

[5] Y. Jing, N. Funabiki, S. T. Aung, X. Lu, A. A. Puspitasari, H. H. S. Kyaw, and W-C. Kao, “A

proposal of mistake correction problem for debugging study in C programming

learning assistant system[J],” Int. J. Info. Edu. Tech. (IJIET), vol. 12, no. 11, pp. 1158-

1163, 2022, doi:10.18178/ijiet.2022.12.11.1733.

[6] N. Funabiki, Tana, K. K. Zaw, N. Ishihara, and W.-C. Kao, “A graph-based blank

element selection algorithm for fill-in-blank problems in Java programming learning

assistant system[J],” IAENG Int. J. Comp. Sci., vol. 44, no. 2, pp. 247-260, 2017.

[7] H. H. S. Kyaw, S. S. Wint, N. Funabiki, and W.-C. Kao, “A code completion problem in

Java programming learning assistant system[J],” IAENG Int. J. Comp. Sci., vol. 47, no.

25
 3, pp. 350-359, 2020.

[8] X. Lu, N. Funabiki, A. A. Puspitasari, K. Ueda, “A study of phrase fill-in-blank problem

for learning basic C programming[J],” Int. J. Info. Edu. Tech. (IJIET), vol. 13, no. 9, pp.

1445-1451, 2023, doi:10.18178/ijiet.2023.13.9.1948.

[9]
P. Lubbers,B. Alers, and F. Salim, Pro HTML5 Programming[M], 2010, pp. 213-241.

[10]
SHA-256 Cryptographic Hash Algorithm,

http://www.movable-type.co.uk/scripts/sha256.html.

[11]
N. Funabiki, H. Masaoka, N. Ishihara, I-W. Lai, and W.-C. Kao, “Offline answering

function for fill-in-blank problems in Java programming learning assistant

system[C],” Proc. Int.Conf.Consumer Electronics-Taiwan(ICCE-TW), pp. 324-325,

2016, doi:10.1109/ICCETW.2016.7521045.

[12]
Programiz: C Program to store data in structures dynamically,

https://www.programiz. com/c-programming/examples/structure-dynamic-

memory-allocation

[13]
S. T. Aung, N. Funabiki, L. H. Aung, H. Htet, H. H. S. Kyaw, and S. Sugawara, “An

implementation of Java programming learning assistant system platform using

Node.js[C],” Proc. Int. Conf. Infor. Edu. Tech.(ICIET), pp. 47-52, 2022,

doi:10.1109/ICIET55102.2022.9779047.

26
[14]
K. H. Wai, N. Funabiki, S. T. Aung, K. T. Mon, H. H. S. Kyaw, and W.-C. Kao, “An

Implementation of Answer Code Validation Program for Code Writing Problem in Java

Programming Learning Assistant System[C],” Proc. Int. Conf. Infor. Edu. Tech.

(ICIET), pp. 193-198, 2023, doi: 10.1109/ICIET56899.2023.10111392.

[15]
Programiz: List of all keywords in C language, https://www.programiz.com/c-

programming/list-all-keywords-c-language

27