maurice12370/is247_teamc

Project Name: Student Management System

What problem is our project trying to solve: The Student Management System (SMS) project aims to solve the problem of managing student records efficiently in an educational institution. It allows administrators to easily add, update, delete, and search for student information. By organizing student data in a structured manner, the system helps keep track of students' personal details, course enrollments, and grades. Additionally, it can generate reports to provide insights into student performance and course participation. This project simplifies the process of handling student information, making it more accessible and manageable for school administrators.

Members: Abdul Jabbar Mohamed Sharif, Ajaybir Singh, Hitesh Patel, Maurice Johnson and Tejasav Singh

Abdul Jabbar Mohamed Sharif:

• Implement the main menu using Scanner Class and switch statement.
• Develop classes for Course and Admin.
• Use conditional operator and this keyword where applicable.

Ajaybir Singh:

• Create the Student class with all necessary fields and methods.
• Implement Inheritance and Method overriding for specialized student types.
• Handle Encapsulation and Constructor implementation.

Hitesh Patel:

• Develop the Report generation module.
• Implement Recursion for hierarchical report generation.
• Manage Generics and ArrayList for storing reports.

Maurice Johnson:

• Implement CRUD operations using Interface and Abstract Class.
• Handle Exception management for invalid operations.
• Work on Static variable and Static methods for utility operations.

Tejasav Singh:

• Implement Stacks for undo functionalities.
• Develop functionalities using Map for student records.
• Utilize Java library classes like Date, and work on Println, printf methods for formatted output.

is247_teamc's Issues

code review for student

Use Java I/O for reading data and writing reports.

Utilize Java I/O (Input/Output) streams to handle the reading and writing of data within the Student Management System. Implement functionality to read student data from files and write generated reports to files. Ensure efficient and reliable data handling to facilitate smooth data operations and accurate report generation, enhancing the overall functionality and usability of the system.

Use generics for flexible data structures (e.g., generic stack implementation).

Implement generics within the Student Management System to create flexible and reusable data structures, such as a generic stack. This approach allows data structures to be parameterized with different types, ensuring type safety and versatility in handling various data elements. By leveraging generics, the system can accommodate diverse data requirements while promoting code reusability and maintainability.

Use the Scanner class for user input and handle exceptions for input validation.

Implement the main menu of the Student Management System by utilizing the Scanner class to receive input from the user. Ensure that all inputs are validated and handle any exceptions that may arise, such as invalid data types or out-of-range values, to prevent crashes and maintain a smooth user experience. This task focuses on the proper capture and management of user inputs through robust exception handling mechanisms.

Project Requirements

Individual Responsibilities

Abdul Jabbar Mohamed Sharif
Main Menu Implementation:
o Use the Scanner class for user input and handle exceptions for input validation.
o Implement menu options using a switch statement for different functionalities (Add, Process, Inquiry, Erase).

Ajaybir Singh
Student Class Development:
o Create the Student class with necessary fields (e.g., name, ID, courses) and methods (e.g., getters, setters).
o Implement inheritance and method overriding for specialized student types (e.g., GraduateStudent, n
UndergraduateStudent).
o Ensure encapsulation and handle constructors for object initialization.

Hitesh Patel
Report Generation Module:
o Develop the module for generating reports on student performance and course participation.
o Implement recursion for generating hierarchical reports (e.g., nested reports for departments and courses).
o Use Java I/O for reading data and writing reports.

Maurice Johnson
APIE Operations:
o Implement Add, Process, Inquiry, and Erase operations using interfaces and abstract classes to define
common behaviors.
o Handle exceptions for operations (e.g., invalid input, non-existing records).
o Implement sorting algorithms (e.g., bubble sort, merge sort) for managing student records.

Tejasav Singh
Data Structures and Advanced Functionality:
o Implement stack data structure for undo functionality and utilize queues for managing background tasks.
o Use generics for flexible data structures (e.g., generic stack implementation).
o Utilize Java library classes such as Date for handling dates and System.out.println, printf for formatted
output.

Handle exceptions for operations (e.g., invalid input, non-existing records).

Implement robust exception handling mechanisms for all core operations (Add, Process, Inquiry, Erase) in the Student Management System. This includes detecting and managing errors such as invalid input and attempts to operate on non-existing records. Ensure that exceptions are appropriately caught and informative error messages are provided to the user, maintaining the system's reliability and user-friendliness.

Implement stack data structure for undo functionality and utilize queues for managing background tasks.

Integrate stack and queue data structures into the Student Management System to support specific functionalities:

Stack for Undo Functionality: Implement a stack to store previous states or actions, allowing users to undo operations such as data modifications or deletions.

Queue for Background Tasks: Utilize a queue to manage background tasks or asynchronous operations, ensuring tasks are processed in an orderly manner without blocking the main application flow.

These data structures enhance the system's functionality by providing mechanisms for managing user actions and background processes efficiently.

Implement inheritance and method overriding for specialized student types (e.g., GraduateStudent, n UndergraduateStudent).

Extend the functionality of the Student class by creating specialized subclasses such as GraduateStudent and UndergraduateStudent. Utilize inheritance to inherit common properties and methods from the Student class, and implement method overriding to customize behaviors specific to each student type. This task ensures that the system can handle different categories of students with their unique attributes and behaviors.

Utilize Java library classes such as Date for handling dates and System.out.println, printf for formatted output.

Incorporate Java's built-in Date class to manage date-related functionalities within the Student Management System. Utilize methods from the Date class to accurately capture and manipulate dates associated with student records, ensuring data consistency and relevance over time.

Implement Add, Process, Inquiry, and Erase operations using interfaces and abstract classes to define common behaviors.

Develop the core operations (Add, Process, Inquiry, Erase) of the Student Management System by utilizing interfaces and abstract classes. Define common behaviors and structure through interfaces and abstract classes to ensure consistency and reusability across different operations. This approach will create a flexible and maintainable codebase, allowing for the efficient implementation and extension of core functionalities.

Compile Code and make sure it runs

Implement recursion for generating hierarchical reports (e.g., nested reports for departments and courses).

Design and implement a recursive approach to generate hierarchical reports within the Student Management System. This involves creating nested reports that can drill down from higher-level entities such as departments to more detailed levels like individual courses. Recursion will enable the system to dynamically build these complex, multi-level reports, providing a comprehensive view of data across different organizational layers.

Create the Student class with necessary fields (e.g., name, ID, courses) and methods (e.g., getters, setters).

Develop the Student class to represent individual students within the Student Management System. Include essential fields such as name, ID, and courses. Implement corresponding methods such as getters and setters to access and modify these fields. This foundational class will serve as the core data structure for managing student information in the system.

Develop the module for generating reports on student performance and course participation.

Create a comprehensive module within the Student Management System to generate detailed reports on student performance and course participation. This module will aggregate and analyze data, producing insightful reports that highlight students' academic achievements and their engagement in various courses. Ensure the reports are clear, informative, and easily accessible to administrators for monitoring and decision-making purposes.

Implement menu options using a switch statement for different functionalities (Add, Process, Inquiry, Erase).

Design and implement the main menu options of the Student Management System using a switch statement. This structure will allow the user to navigate different functionalities, including adding new student records, processing existing records, inquiring about specific data, and erasing records. Ensure each menu option is clearly defined and leads to the corresponding functionality, providing a user-friendly and organized navigation system.

Ensure encapsulation and handle constructors for object initialization.

Design the Student class to follow the principles of encapsulation by keeping fields private and providing public getters and setters for access and modification. Implement constructors to initialize Student objects with necessary fields such as name, ID, and courses. This ensures that student data is safely managed and objects correctly instantiate with required information.

Fix up the readme section

Implement sorting algorithms (e.g., bubble sort, merge sort) for managing student records.

Develop and integrate sorting algorithms within the Student Management System to efficiently manage student records. Implement algorithms such as bubble sort or merge sort to organize student data based on specified criteria (e.g., by name, by ID). Ensure that the sorting process is optimized for performance and scalability, enhancing the system's capability to handle and present sorted student information effectively.