Final Course Project: University Course Management

System (UCMS) in Java

This project aims to showcase the following learning outcomes achieved throughout the
Object-Oriented Programming (OOP) course in Java:

1. Understanding of Classes and Objects:

● Students will design and implement core classes representing entities in a university
system (e.g., Course, Faculty, Student, Enrollment).
● Each class will encapsulate relevant attributes (data members) and methods (functions)
specific to the entity.
● Constructors will be used to initialize objects with appropriate data.

2. Applying Inheritance:

● The project can explore inheritance by creating a base class Person with common
attributes (e.g., name, ID) shared by Student and Faculty.
● Derived classes (Student, Faculty) will inherit properties from the base class while
adding specific attributes and methods.

3. Encapsulation and Data Access Control:

● Students will utilize access modifiers (public, private, protected) to control access to
attributes within classes.
● Getter and setter methods will be implemented to provide controlled access to private
data while maintaining encapsulation.

4. Polymorphism in Action:

● The project can introduce polymorphism by defining abstract methods in a base class
(e.g., Person) for actions like displaying information.
● Derived classes (Student, Faculty) will implement these methods in their own way,
showcasing polymorphic behavior.

5. Utilizing Collections and Data Structures:

● Students will leverage Java collections (e.g., ArrayList, HashMap) to store and manage
university data efficiently.
● This could involve storing courses in an ArrayList, managing student enrollments
using HashMaps, or creating waitlists with appropriate data structures.

6. Exception Handling:
 ● The project can incorporate exception handling to manage potential errors that might
occur during program execution (e.g., trying to enroll in a full course).
● Students will implement try-catch blocks to handle exceptions gracefully and ensure
program stability.

7. Optional: User Interface (UI) Integration

● For an extended challenge, students can explore integrating a basic user interface (UI)
using Java Swing libraries or a framework like JavaFX.
● This allows users to interact with the UCMS through menus and forms for
adding/removing courses, managing students and faculty, and enrolling/withdrawing
from courses.

8. Persistence (Optional):

● For a more advanced challenge, students can explore using Java Database Connectivity
(JDBC) or an Object-Relational Mapper (ORM) like JPA to persist data in a relational
database.
● This allows data to be saved and retrieved even after the program terminates, providing
a more robust system.

Assessment Criteria:

● Code Quality and Functionality (60%): Completeness, correctness, and efficiency of

the implemented code.
● Object-Oriented Design Principles (20%): Effective use of classes, inheritance,
encapsulation, and polymorphism.
● Documentation and Readability (10%): Clear comments, meaningful variable names,
and well-organized code structure.
● Optional UI (5%): Functionality, usability, and design of the user interface (if
implemented).
● Optional Persistence (5%): Correct implementation of data persistence using a
database (if implemented).

This final project allows students to demonstrate their understanding of key OOP concepts and
their ability to apply them in a practical scenario. By building a University Course Management
System, they gain valuable experience in designing classes, managing data, and creating a
functional program using object-oriented principles in Java.