Sprint Challenge: Task Management System

# 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.