Sprint Challenge: Task Management System

Inizia creando i package tasks, management e main descritti nell’issue, con Task e tipi di task specializzati, TaskManager e Main. Usa i requisiti e i criteri di accettazione elencati per guidare la progettazione, quindi esegui Main per verificare la creazione e il completamento dei task, i riepiloghi polimorfici e la prevenzione degli stati non validi.

Sprint Challenge: Task Management System

The code you write for this challenge is mandatory homework and should be completed and sent in a PR for review before class.

This challenge combines all the object-orientated programming concepts you've learned so far. You'll see how classes, encapsulation, inheritance, polymorphism, packages, and static/final keywords form a cohesive system for building well-structured Java applications.

Background

You are working for a company that wants to track different types of tasks in a project. Each task has a description, a unique identifier, and a completion status. Some tasks have special behaviour or additional data, such as deadlines or priority levels.

Your job is to create a small system that models tasks, enforces valid state, and allows tasks to be managed using polymorphism.

Requirements

Design a system that models tasks, manages them, and prints a simple summary of task states to the console.

Task Behaviour

All tasks should:

• Have a unique identifier
• Have a human-readable description
• Be able to be completed
• Prevent invalid states, e.g. cannot be completed twice

Specialised Task Types

The system must support at least two specialised task types. These types should:

• Inherit from the base Task class
• Add additional state or behaviour of their own
• Behave differently at runtime when treated as a generic Task

Some examples could be a timed task with a deadline, or priority task with prioritisation

Task Management

Create a TaskManager class responsible for:

• Storing tasks (using a fixed-size array, e.g. max 10 tasks)
• Adding new tasks
• Completing tasks by ID
• Returning tasks based on completion status
• The TaskManager should not need to know concrete task types

Code Organisation

Your code should be organised into multiple packages:

• tasks → contains Task and specialised task types
• management → contains TaskManager
• main → contains Main class with a main method to demonstrate behaviour

Acceptance Criteria

The system should:

• Log task summaries to the console in a human-readable format
• Show each task's ID, description, type, and completion status
• Demonstrate polymorphism at runtime (e.g., calling overridden methods on different task types without checking type)
• Prevent any task from entering an invalid state
• Compile and run without errors
• Use proper encapsulation (no public fields)
• Use final or static where appropriate

Main method expectations:

• Create a TaskManager
• Add several different task types
• Complete some tasks
• Print task summaries to the console

Developer Guidance (May just use for reference)

Let's start by modelling the data:

Class Task

• Fields:
• private final int id (unique)
• private String description
• private boolean completed
• Methods:
• public void complete() → mark as completed, prevent double-completion
• public String getStatus() → returns a human-readable status
• Consider using static for generating unique IDs

Specialised Tasks

• Create at least two subclasses (e.g., TimedTask, PriorityTask)
• Add additional fields (e.g., deadline, priority)
• Override methods to demonstrate polymorphic behaviour

TaskManager

• Fields:
• private Task[] tasks
• private int taskCount
• Methods:
• public void addTask(Task task)
• public void completeTask(int id)
• public Task[] getTasksByStatus(boolean completed)

Main

• Create a simple demo of your system, showing tasks being added, completed, and summaries printed

Reflection Questions

• Where did polymorphism remove the need for conditional logic?
• Which responsibilities are shared across all tasks, and which are specific?
• Where did encapsulation prevent misuse of an object?
• If a new task type were added, how much existing code would need to change?

Submission & Review

Fork the coursework repo to your own GitHub account.
Make regular small commits with clear messages.
When you are ready, open a Pull Request to the CYF repo. Make sure you fill in the PR template provided.
A volunteer will review your submission and send you feedback.