Student Management System

Project Overview

A comprehensive Java-based Student Management System that enables educational institutions to manage students, courses, and enrollments efficiently. The system provides a console-based interface with robust data persistence and business logic implementation.

Features

Three Major Functional Modules

1. Student Management Module

• Add New Students: Register students with personal information (ID, name, email, phone, DOB)
• View All Students: Display complete list of registered students with their details
• Search Students: Search students by name with partial matching
• Update Student Information: Modify existing student records
• Delete Students: Remove student records from the system
• GPA Tracking: Automatic calculation and tracking of student GPA

2. Course Management Module

• Add New Courses: Create courses with details (ID, name, code, instructor, credits, department)
• View All Courses: Display available courses with enrollment information
• Search Courses: Search courses by name or department
• Update Course Information: Modify course details and capacity
• Delete Courses: Remove courses from the system
• Capacity Management: Track available seats and maximum capacity

3. Enrollment Management Module

• Enroll Students: Register students in courses with validation
• Drop Courses: Allow students to withdraw from courses
• Grade Assignment: Assign numeric and letter grades to students
• View Enrollments: Display student-course relationships
• GPA Calculation: Automatic GPA computation based on grades
• Enrollment Validation: Prevent duplicate enrollments and capacity violations

Additional Features

• Reports & Analytics: System-wide statistics and insights
• Data Persistence: File-based storage for all entities
• Comprehensive Logging: Application activity tracking
• Input Validation: Robust validation for all user inputs
• Error Handling: Graceful exception handling throughout the system

Technologies/Tools Used

• Language: Java 8+
• Architecture: Layered Architecture (UI → Service → Repository)
• Design Patterns:
  • Repository Pattern
  • Service Layer Pattern
  • Singleton Pattern (Logger)
• Data Storage: File-based serialization (.dat files)
• Input/Output: Console-based UI using Scanner
• Error Handling: Custom exception hierarchy
• Logging: File and console logging system

Project Structure

JAVA Project/
├── src/
│   └── com/
│       └── studentmanagement/
│           ├── Main.java
│           ├── model/
│           │   ├── Student.java
│           │   ├── Course.java
│           │   ├── Enrollment.java
│           │   └── User.java
│           ├── service/
│           │   ├── StudentService.java
│           │   ├── CourseService.java
│           │   └── EnrollmentService.java
│           ├── repository/
│           │   ├── StudentRepository.java
│           │   ├── CourseRepository.java
│           │   └── EnrollmentRepository.java
│           ├── ui/
│           │   └── ConsoleUI.java
│           ├── util/
│           │   ├── Logger.java
│           │   └── InputValidator.java
│           └── exception/
│               ├── ValidationException.java
│               ├── DuplicateEntityException.java
│               ├── EntityNotFoundException.java
│               └── BusinessLogicException.java
├── data/
│   ├── students.dat
│   ├── courses.dat
│   └── enrollments.dat
├── logs/
│   └── application.log
├── docs/
│   ├── diagrams/
│   │   ├── use-case-diagram.png
│   │   ├── class-diagram.png
│   │   ├── sequence-diagram.png
│   │   └── er-diagram.png
│   └── Database_Schema.md
├── README.md
├── statement.md
└── BuildYourOwnProject.pdf

Installation & Setup

Prerequisites

• Java Development Kit (JDK) 8 or higher
• Command line terminal (PowerShell, CMD, or Bash)
• Text editor or IDE (VS Code, IntelliJ IDEA, Eclipse)

Steps to Install & Run

1. Clone or Download the Repository

   cd "c:\Users\killi\OneDrive\Documents\JAVA Project"

2. Compile the Java Source Files

   javac -d bin src/com/studentmanagement/**/*.java src/com/studentmanagement/*.java

3. Run the Application

   java -cp bin com.studentmanagement.Main

Alternative: Using IDE

1. Open the project folder in your IDE (IntelliJ IDEA, Eclipse, or VS Code with Java extension)
2. Ensure JDK is configured
3. Run the Main.java file

How to Use

Starting the Application

Run the Main class to launch the console interface. You'll see the main menu with options for managing students, courses, and enrollments.

Main Menu Options

1. Student Management

   • Add students with required information
   • View, search, update, or delete student records
   • System validates email format and required fields

2. Course Management

   • Create courses with instructor and capacity details
   • Manage course information and enrollment capacity
   • Search courses by name or department

3. Enrollment Management

   • Enroll students in available courses
   • Drop courses with proper validation
   • Assign grades and track academic performance

4. Reports & Analytics

   • View system statistics (total students, courses, enrollments)
   • Analyze student performance (average GPA)
   • Monitor course capacity and availability

Example Usage Flow

1. Add a new student (Student Management → Add New Student)
2. Add a new course (Course Management → Add New Course)
3. Enroll the student in the course (Enrollment Management → Enroll Student)
4. Assign grades (Enrollment Management → Assign Grade)
5. View reports (Reports & Analytics → System Statistics)

Testing

Manual Testing Instructions

1. Test Student Management

   • Add multiple students with valid/invalid data
   • Search for students by name
   • Update student information
   • Verify data persistence by restarting the application

2. Test Course Management

   • Create courses with various capacities
   • Test course full condition
   • Search and filter courses

3. Test Enrollment Management

   • Enroll students in courses
   • Test duplicate enrollment prevention
   • Test capacity validation
   • Assign grades and verify GPA calculation

4. Test Error Handling

   • Try to add duplicate student IDs
   • Attempt to enroll in full courses
   • Enter invalid email formats
   • Test with empty required fields

Expected Behaviors

• All inputs are validated before processing
• Duplicate IDs are rejected
• Full courses prevent new enrollments
• GPA is automatically calculated from grades
• All operations are logged to file
• Data persists across application restarts

Non-Functional Requirements

1. Performance: Operations complete in < 1 second for datasets up to 1000 records
2. Reliability: Data integrity maintained through serialization; crash recovery supported
3. Usability: Intuitive console interface with clear prompts and error messages
4. Maintainability: Modular architecture with separation of concerns; well-documented code
5. Scalability: Can handle thousands of students and courses; file-based storage easily upgradeable to database
6. Security: Input validation prevents injection attacks; data stored in binary format
7. Error Handling: Comprehensive exception handling with user-friendly error messages
8. Logging: All operations logged for audit and debugging purposes

Screenshots

Main Menu

============================================================
     STUDENT MANAGEMENT SYSTEM
============================================================
Welcome to the Student Management System!
Manage students, courses, and enrollments efficiently.

------------------------------------------------------------
MAIN MENU
------------------------------------------------------------
1.  Student Management
2.  Course Management
3.  Enrollment Management
4.  Reports & Analytics
5.  Exit
------------------------------------------------------------

Student List View

=== All Students ===
ID           Name                 Email                          GPA    Status    
--------------------------------------------------------------------------------
S001         John Doe             john.doe@email.com             3.75   ACTIVE    
S002         Jane Smith           jane.smith@email.com           3.90   ACTIVE    

Total Students: 2

Design Decisions & Architecture

Layered Architecture

• Presentation Layer (UI): ConsoleUI handles user interaction
• Business Logic Layer (Service): Service classes implement business rules
• Data Access Layer (Repository): Repository classes handle data persistence
• Domain Layer (Model): Entity classes represent business objects

Key Design Patterns

• Repository Pattern: Abstracts data access logic
• Service Layer Pattern: Encapsulates business logic
• Exception Hierarchy: Custom exceptions for different error types

Future Enhancements

1. Web-Based Interface: Develop a Spring Boot REST API with React frontend
2. Database Integration: Migrate from file storage to MySQL/PostgreSQL
3. Authentication & Authorization: Implement role-based access control
4. Email Notifications: Send enrollment confirmations and grade notifications
5. Advanced Reporting: Generate PDF reports and data visualizations
6. Bulk Operations: Import/export students and courses via CSV
7. Course Prerequisites: Implement prerequisite validation for enrollments
8. Payment Integration: Track and manage tuition payments
9. Attendance Tracking: Monitor student attendance in courses
10. Mobile Application: Develop Android/iOS apps for students and faculty

Developer

• Developer: Akshat Kumar Singh
• Role: Solo Developer & Architect
• GitHub: @AkshatKumarSingh001
• Version: 1.0
• Date: November 2025

License

This project is created for educational purposes as part of academic coursework.

---

Note: This is an academic project developed to demonstrate Java programming concepts including OOP, data structures, file I/O, and software design patterns.