1

Mini project
Java programming -22CS302

STUDENT GRADING SYSTEM

By:

V.Dinesh Babu -720822103047

J.Bala pragashpathi-720822103025
G.Arivu. -720822103019
V.Abishek. -720822103008
 ABSTRACT

STUDENT GRADING SYSTEM (SGS) deals with the maintenance of university, college,
faculty, student information within the university. SGS is an automation system, which is used to
store the college, faculty, student, courses and information of a college.

Starting from registration of a new student in the college, it maintains all the details regarding the
attendance and marks of the students. The project deals with retrieval of information through an
INTRANET based campus wide portal. It collects related information from all the departments
of an organization and maintains files, which are used to generate reports in various forms to
measure individual and overall performance of the students.

Development process of the system starts with System analysis. System analysis involves
creating a formal model of the problem to be solved by understanding requirements.
 CHAPTER 1

INTRODUCTION

Grades are standardized measurements of varying levels of comprehension within a subject area.
Grades can be assigned in letters (for example, A, B, C, D, E, or F), as a range (for example 4.0–
1.0), as descriptors (excellent, great, satisfactory, needs improvement), in percentages, or, as is
common in some post-secondary institutions in some countries, as a Grade Point Average
(GPA). GPA is calculated by taking the number of grade points a student earned in a given
period of time divided by the total number of credits taken. The GPA can be used by potential
employers or further post-secondary institutions to assess and compare applicants. A Cumulative
Grade Point Average is a calculation of the average of all of a student's grades for all semesters
and courses completed up to a given academic term, whereas the GPA may only refer to one
term.

MOTIVATION

System metric and student show that result and mark All-to-often grades are used inappropriately
as a manipulative tool to get students to class.

OBJECTIVE

This is a web-based database application for a university where students and instructors will be
able to use the system to perform their related operations like checking and assigning of grades
respectively. It is a role based access system where every user login is authenticated by means of
a user name and password with which he/she will be able to login to his/her respective pages and
use the system as required.
PURPOSE OF THE SYSTEM

STUDENT GRADING SYSTEM (SGS) deals with the maintenance of university, college,
faculties, student information within the university. This project of SGS involved the automation
of student information that can be implemented in different college managements

The project deals with retrieval of information through an INTRANET based campus wide
portal. It collects related information from all the departments of an organization and maintains
files, which are used to generate reports in various forms to measure individual and overall
performance of the students.

EXISTING SYSTEM

The system starts with registration of new staff and students. When the subjects are to be
allocated to the faculty, the Head of the Department should enter everything in the Excel sheets.
Then the staff enters corresponding subject’s attendance and marks of a student then those must
also be entered in the Excel sheets and validations are to be done by the user itself. So there will
be a lot of work to be done and must be more conscious during the entrance of details. So, more
risk is involved.

PROBLEMS IN THE EXISTING SYSTEM:

Storing and accessing the data in the form of Excel sheets and account books is a tedious work. It
requires a lot of laborious work. It may often yield undesired results. Maintaining these records
as piles may turn out to be a costlier task than any other of the colleges and institutions

RISKS INVOLVED IN EXISTING SYSTEM:

 Present System is time-consuming and also results in lack of getting inefficient results.

 Some of the risks involved in the present system are During the entrance of marks and
attendance, if any mistake is done at a point, then this becomes cumulative and leads to
adverse consequences

 If there is any need to retrieve results it may seem to be difficult to search.

PROPOSED SYSTEM

STUDENT GRADING SYSTEM (SGS) makes management to get the most updated
information always by avoiding manual accounting process. This system has the following
functional divisions.

 University Administrator

 College Administrator

 User (Students / Faculties).

College Administrator has the rights of creating department, allocating courses to departments,
creating faculties, students and allocating subjects to faculties and modifications in the data
entered by the user can also be done by the college administrator.

User of this may be faculty or students. Faculty has the facility of entering the marks and
attendance of the students. Students can check their marks and attendance but there is no chance
of modifications.

Reports must be generated for the existing data i.e. for attendance and marks of the students,
which are used to assess the performance of the students. These reports should be viewed by the
in charge and user.
5

Modulus Discription

Certainly! In the context of a student grading system using Java,

the modulus operation (% in Java) can be employed for various
purposes, such as:

1. **Grade Categorization:**
- Use modulus to categorize grades based on certain criteria.
For example, you could categorize students into different groups
by applying modulus to their scores, making it easier to identify
high achievers, average performers, and those needing
improvement.

2. **Circular Grade Scales:**

- Implementing a circular grade scale where, for instance, a
score of 95% and 5% are considered equivalent. Modulus can be
utilized to create a continuous loop in the grading scale,
ensuring that scores beyond a certain threshold wrap around to
the lower end.

3. **Customized Weighted Modulus:**

- Apply weighted modulus to adjust the impact of different
assessment components. This allows for a more flexible grading
system where certain exams or assignments contribute more
significantly to the final grade.

4. **Data Validation:**
- Use modulus to validate input data. For instance, if grades are
expected to fall within a specific range (e.g., 0 to 100), applying
6

modulus can help ensure that entered grades adhere to this

range.

5. **Randomization:**
- Incorporate modulus in randomization processes related to
grading. This can add an element of unpredictability, such as in
scenarios where a small percentage of students receive bonus
points.

By strategically incorporating the modulus operation, the student

grading system becomes more adaptable and can cater to
specific grading policies and requirements.

1.USER MODULE

In the context of a student grading system using Java, a "User

Module" could involve functionalities related to user
authentication, access control, and user-specific interactions.
Here's an overview:

1. **User Authentication:**
- Implement a secure login system using Java to authenticate
users. Validate credentials against a secure database to ensure
only authorized individuals have access to the grading system.

2. **User Roles and Permissions:**

- Define different user roles (e.g., teacher, administrator) and
assign specific permissions accordingly. Java can help manage
7

roles and control access to features and data based on user

privileges.

3. **User Profile Management:**

- Allow users to update their profiles, including personal details
or password changes. Java can facilitate the creation of
user-friendly interfaces for profile management.

4. **Logging and Auditing:**

- Implement logging mechanisms using Java to track user
activities within the grading system. This can aid in auditing,
ensuring accountability, and tracking any changes made by
users.

5. **Password Encryption:**
- Utilize Java's encryption capabilities to securely store and
manage user passwords. This enhances the overall security of
the system by protecting sensitive information.

6. **Session Management:**
- Implement session management to handle user sessions
effectively. Java can help create and manage session tokens,
ensuring secure and efficient user interactions.

7. **User Notifications:**
- Use Java to incorporate a notification system, keeping users
informed about relevant updates, such as grade submissions,
system changes, or announcements.

8. **User Interactions with Grades:**

- Tailor the interface to allow users (teachers, administrators) to
input, modify, and retrieve grades based on their roles. Java can
8

facilitate the creation of user-friendly forms for these

interactions.

By integrating these features into the user module, the student

grading system becomes not only secure but also user-centric,
providing a smooth and controlled experience for all
stakeholders.

2.ADDRESS MODULE

In the context of a student grading system using Java, an

"Address Module" could be designed to manage and store
student addresses. Here's how you might structure it:

1. **Student Address Class:**

- Create a Java class representing a student's address. This
class could include attributes like street address, city, state, ZIP
code, and any other relevant details.

```java
public class StudentAddress {
private String streetAddress;
private String city;
private String state;
private String zipCode;

// Constructors, getters, and setters

}
```
9

2. **Integration with Student Class:**

- Integrate the `StudentAddress` class into the main `Student`
class to associate each student with their respective address.

```java
public class Student {
private String studentId;
private String firstName;
private String lastName;
private StudentAddress address;

// Constructors, getters, and setters

}
```

3. **Address Input and Validation:**

- Implement methods in Java to input and validate address
details, ensuring data integrity. This can include checks for valid
ZIP codes, city names, etc.

4. **Address Management in Database:**

- Design a mechanism to store and retrieve address information
from a database. Utilize Java's database connectivity (JDBC) to
interact with a database, storing and retrieving addresses
associated with each student.

5. **User Interface for Address Entry:**

- Create a user interface using Java GUI libraries or web
frameworks that allows administrators or users to input and
update address details for each student.
10

6. **Address Formatting:**
- Implement formatting methods in Java to ensure consistency
and standardization in the display of addresses, enhancing the
user experience.

By incorporating these elements, the Address Module enhances

the student grading system by providing a structured and
organized approach to managing student addresses. It ensures
that address-related information is accurately captured, stored,
and presented within the system.

3.DATA BASE MODULE

For the database module in a student grading system using

Java, you would likely employ a relational database to store and
retrieve student information, grades, and related data. Here's an
outline of how you could structure this:

1. **Database Connection:**
- Use Java Database Connectivity (JDBC) to establish a
connection between your Java application and the relational
database (e.g., MySQL, PostgreSQL).

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnection {

11

private static final String URL =

"jdbc:mysql://localhost:3306/your_database";
private static final String USER = "your_username";
private static final String PASSWORD = "your_password";

public static Connection getConnection() throws

SQLException {
return DriverManager.getConnection(URL, USER,
PASSWORD);
}
}
```

2. **Student Table:**
- Create a table in the database to store student information,
including student ID, first name, last name, and any other
relevant details.

3. **Grades Table:**
- Establish a table to store grades associated with each
student, including the course ID, grade value, and any additional
information.

4. **Address Table:**
- If you've implemented an Address Module, create a table to
store address details for each student.

5. **Queries and CRUD Operations:**

- Develop Java methods to perform CRUD (Create, Read,
Update, Delete) operations on the database. These methods
should include SQL queries to interact with the tables.
12

6. **Data Validation:**
- Implement data validation checks within your Java application
to ensure that only valid and consistent data is stored in the
database.

7. **Connection Pooling (Optional):**

- Consider implementing connection pooling for efficient
handling of database connections, especially in scenarios with
multiple simultaneous users.

8. **Error Handling:**
- Implement robust error handling mechanisms within your
Java code to manage exceptions that may occur during database
operations.

By incorporating these components, your Java application can

effectively interact with a relational database, ensuring seamless
storage and retrieval of student-related data in the context of a
grading system.

Source code

package finalyearproject;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
13

import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;

/**
*
* @author Prof Oyondi
*/
public class GradesTable extends javax.swing.JFrame {

/**
* Creates new form GradesTable
*/
public GradesTable() {
initComponents();
show_Student_Details();
}
public Connection createConnection()
{

Connection conn = null;

//try to connect to the studentsdb
try{

Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/studentsdb";
String user = "root";
String password = "";
conn = DriverManager.getConnection(url,user ,password);

return conn;
}catch(Exception e){
14

//print error message if not connected

e.printStackTrace();
return null;
}
}

public ArrayList<StudentInfo> getstudentsList()

{
ArrayList<StudentInfo> sList = new
ArrayList<StudentInfo>();
Connection connect = createConnection();
String query = "SELECT * FROM `students`";
Statement stmt;
ResultSet res;
try{
stmt = connect.createStatement();
res = stmt.executeQuery(query);
StudentInfo stud;
while(res.next())
{
stud = new
StudentInfo(res.getInt("id"),res.getString("username"),res.getInt(
"HomeWork"),res.getInt("TEST"),res.getInt("total"),res.getString(
"grade"));
sList.add(stud);
}
}catch(Exception ex){
ex.printStackTrace();
}
return sList;
}
15

//show student details on the jTable

public void show_Student_Details()
{
ArrayList<StudentInfo> list = getstudentsList();
DefaultTableModel model =
(DefaultTableModel)students_table.getModel();
Object[] data = new Object[6];
for(int i = 0; i < list.size(); i++)
{
data[0] = list.get(i).getSID();
data[1] = list.get(i).getSName();
data[2] = list.get(i).getHScore();
data[3] = list.get(i).getSTest();
data[4] = list.get(i).getTotals();
data[5] = list.get(i).getSGrade();

model.addRow(data);
}
}
/**
* This method is called from within the constructor to initialize
the form.
* WARNING: Do NOT modify this code. The content of this
method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated
Code">
private void initComponents() {

jPanel1 = new javax.swing.JPanel();

34

try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {

javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(MainApp.class.getName()).log
(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(MainApp.class.getName()).log
(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(MainApp.class.getName()).log
(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex)
{

java.util.logging.Logger.getLogger(MainApp.class.getName()).log
(java.util.logging.Level.SEVERE, null, ex);
}
//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
35

new MainApp().setVisible(true);
}
});
}

// Variables declaration - do not modify

private javax.swing.JButton jButton1;
private javax.swing.JButton jButton2;
private javax.swing.JButton jButton3;
private javax.swing.JButton jButton4;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
public javax.swing.JTextField stud_hwScore;
public javax.swing.JTextField stud_id;
public javax.swing.JTextField stud_name;
public javax.swing.JTextField stud_tScore;
// End of variables declaration
}
This module is the main module of the system that includes
adding, Updating, and viewing the student grades.

About The Student Grading System Project In Java

Project Name: Student Grading System Project
Language/s Used: JAVA
Database:MySQL
Type: Desktop Application
Developer: IT SOURCECODE
Updates: 0
Student Grading System Project In Java– Project Information
 LITERARY SURVEY

Most colleges and universities and some private schools offer a pass/fail grading system for at
least some of their courses. In some institutions, pass/fail is the only option for some or all of
their courses.

Student grading system is different from the traditional five-interval grading system that gives
students A, B, C, D or F grades to give them an idea of their academic standing and progress
This system of a clear boundary between making the grade or falling short has benefits for
students individually as well as collectively.

TYPES OF GRADING

Mastery Grading
Grading Scale
Letter Grades

PERSONAL BENEFITS

Students work hard to attain their grades without worrying about competition. In the case of
younger students, this also builds self-esteem and confidence, as the grade does not compare
with other students --- it is simply a statement of their own merit and skill. In the tiered system of
grades, there is competition, and students might suffer from inferiority complexes if their grades
are lower than those of their peers. In the case of older students in professional courses, it helps
in the same way: the focus turns to achieving your own personal best.

FEATURES

Central database: Collect and report all of your school's student and staff information.

School customizable: Customize the program to meet your school's data collection and
reporting needs.

User customizable: Each user can customize the program for their specific job responsibilities.
Search and analyze: Search and report based on any information in the database. Break down
the student body by race, gender, age, etc.

Batch entry: Quickly and easily enter information into the records of all or a group of students.
Report writer: Comprehensive report writer lets you create any type of report, letter, label,
sophisticated report, or other document.

Customize reports: Customize any report you need to meet your exact needs.

Data merge: Print mailing labels merging any student information; save your secretary hours of
labor.

Export Easily: Export student data to other programs.

Flexible security: You choose the level of security appropriate for your school.

E-Mail Tools: E-mail any document, letter or report you create in Administrator's Plus using our
e-mail module.

Multi-language reports: The report writer supports multiple languages for many reports.

While grade scales in the U.S. are fairly standard, debates and questions about grading continue
today. There are similar questions about variability, because grading can be a subjective process,
as well as more philosophical questions about the relationship of grades to learning. Finally, even
the grade scale itself is not exactly the same at all schools.

Universities have always evaluated students, but the modern grading system did not always exist.
In fact, in the 18th century, there was no standardized means of evaluating students, and certainly
no means by which student performance at one institution could be easily compared with student
performance somewhere else. One of the first instances of an attempt to evaluate students
systematically .

GPA will be used to measure the academic standing of a student. The Current GPA is calculated
based on the graded modules taken in that semester. Please refer to the following illustration on
the computation.

The method of computing the Current Grade Point Average (Current GPA) for six modules with
one non-graded module, in a particular semester is as shown below:

Sum of ( Credit Units x Grade Points)

Current GPA = ------------------------------------------------------------------------------
Total current semester credit units (graded modules)

Credit (Credit Unit

Module Grade Grade Point
Unit x Grade Point)
Module A 4 AD 4.0 16
Module B 5 A 4.0 20
Module C 5 B 3.0 15
Module D 4 C+ 2.5 10
Module E 2 F 0.0 0
Module F 3 PX - -
Total credit units enrolled 23

Less credit units of non-graded

3
module (Module F)
Total
61

Total credit units earned

20
for the semester

Sum of ( Credit Units x Grade Points)

Current GPA = ------------------------------------------------------------------------------
Total current semester credit units (graded modules)
16 + 20 + 15 + 10 + 0
= ----------------------------------
4 + 5 + 5 + 4+ 2

61
= ----------
20

= 3.05

This system can be represented in a table, as follows:

 Average
Grade Definition
percentage

S 100% Honor & Excellent

A 90% A particularly outstanding achievement
B 80% An achievement that surpasses the average standard
C 70% An achievement that fulfills the average standard
D 60%
E 50%

Fail - considerable further work is required.

F Indescribably bad performance, total absence or failure to take any exams or do
any work.

Equivalency to other grade systems

ECTS SCALE U.S. Grade equivalents Swiss Grade equivalent German Grade equivalent
A A 6 1.0-1.2
B A-/B+ 5.5 1.3-1.5
C B 5 1.6-2.5
D C+ 4.5 2.6-3.5
E C 4 3.6-4.0
FX F 3.5 4.1
F F 3

INPUT AND OUTPUTS:

The major inputs and outputs and major functions of the system are follows:

INPUTS:

 University Administrator enter his user id and password for login to authenticate in this
system

 University Administrator creates the college.

 While registration Colleges can able to provide their information like

 College id

 College name

 Address Information of college

 Password for the college

 Administrator can create the various college details in this website.

 Registered colleges and staff need to submit their log in information for change their
password.

 For searching College details guest need to choose the colleges or search college option
for user interface.

 For searching a college a guest can choose search college option.

 For upload their details’ a college must login to their profile

 For display they have to view the reports.

OUTPUTS:

 Administrator can have his own home page. Colleges ans staff and student have their
own home page after completion of the authentication process.

 Admin get all colleges and staff and course details.

  The registered user’s data can be stored in centralized database through the system user
interface.

 Various types of information can be displayed to the users like colleges, courses and
course subjects etc

 After successful submission of log in information users can got their new password.

 Profile can be update by the users individually.

MODULES

The online test created for taking online test has following stages

o Administrator Login

o User Login

o SMS Setting ( WEB interfce)

ADMINISTRATOR

 Enter student grade for a course

 Update student grade for a course

 Search for student record (based on student ID or student name)

 Run reports to calculate class performance

 Run reports to enquire grades for any student in the class

LOGIN:-

There is a quality login window because this is more secure than other login forms as in a
normal login window there are multiple logins available so that more than one person can access
to test with there individual login. But in this project there is only one login id i.e. administrator
id and password by which a person enter the site. Hence it is more secure and reliable than
previously used on-line test simulators.

STUDENT

 View all the courses taken for that particular period

 Check grade in the courses

 Get transcript (entire grade history)

 Compare his/her performance with the class

Login Management: The initial login screen for Online Grading System

User Management: Create/Edit a user account

Report: Allows either a student or the administrator to run reports.

PROCESS MODEL USED WITH JUSTIFICATION

ACCESS CONTROL FOR DATA WHICH REQUIRE USER AUTHENTICAION

The following commands specify access control identifiers and they are typically used to
authorize and authenticate the user (command codes are shown in parentheses)

USER NAME (USER)

The user identification is that which is required by the server for access to its file system. This
command will normally be the first command transmitted by the user after the control
connections are made (some servers may require this).

PASSWORD (PASS)

This command must be immediately preceded by the user name command, and, for some sites,
completes the user's identification for access control. Since password information is quite
sensitive, it is desirable in general to "mask" it or suppress type out..

This application must be able to produce output at different modules for different inputs.
SGS (STUDENT GRADING SYSTEM) makes management to get the most updated
information always by avoiding manual accounting process.

• University Administrator

• College Administrator

• User (Students / Faculties)

• Reports

• Authentication

SYSTEM ARCHITECTURE

Data flow Diagram

Level 0

USER DATA BASE

LOGIN

View the info about Admin

User Grade
registrati Update
on

View MArk / delete view comp info &

EXAM offers

Admin
 Retrieve Mark Reports Retrieve
Mark info & Mark offers

Database

Figure : 1

USER REGISTRATION
LEVEL 1

User

Homepag
e

Registration
Exam Search
Form

Checks
For

Valid
NO User

YES
 Figure : 3

Clear Diagram
User
 Error Page Message

Figure: 2

Clear Diagram

USER

LOGIN

Go Through Login Page

Authentication
processing

YES
NO

Failed Registration
accepted
 Homepag
e

Is he
Reg.
User

YES NO
Error Form
Login

Error Page

Successf
ul
NO YES

Grading
Process
A dd /
Remove MARK

Authenticat
User ID & ion SMS
Password Setting

Figure : 4

UML DIAGRAM

Registration
Screenshot
36

DFS DIAGRAM

Conclusion

In conclusion, the student grading system developed using Java

represents a significant leap forward in academic management.
Through the integration of Java's versatile features, the system
offers a comprehensive solution that addresses the limitations of
traditional grading approaches.

The modular design ensures scalability, allowing for easy

adaptation to evolving educational requirements. The user
module enhances security and personalization, providing a
37

tailored experience for educators and administrators. Meanwhile,

the address module contributes to the organization and
accessibility of student information.

Central to the system's success is the robust database module,

facilitating efficient data storage, retrieval, and management. The
utilization of JDBC ensures seamless communication between
the Java application and the relational database, optimizing the
handling of student records and grades.

By streamlining processes, enhancing security, and

incorporating user-friendly interfaces, the student grading
system using Java stands as a testament to the power of
technology in revolutionizing academic administration. This
innovative approach not only simplifies the grading process but
also sets the stage for future advancements in educational
management systems.