Task Manager Project – Full Guided Version

🎯 Project Goal

You will build a structured Task Manager using Object-Oriented Programming.
You must understand both the code and the system structure.

📐 System Structure

Main (Control Layer)
        ↓
TaskManager (Logic Layer)
        ↓
Task (Data Model Layer)

• Main → controls execution
• TaskManager → manages collection of tasks
• Task → represents one task

📊 UML Diagram

Task

-------------------------
|        Task           |
-------------------------
| - title : String      |
| - priority : int      |
| - completed : boolean |
-------------------------
| + Task(...)           |
| + markCompleted()     |
| + getPriority()       |
| + toString()          |
-------------------------

TaskManager

-------------------------------
|       TaskManager           |
-------------------------------
| - tasks : ArrayList   |
-------------------------------
| + TaskManager()             |
| + addTask(Task t)           |
| + displayTasks()            |
| + findTask(String title)    |
| + sortByPriority()          |
| + saveToFile()              |
-------------------------------

💻 Full Code – Step by Step

1️⃣ Task.java

public class Task {

    private String title;
    private int priority;
    private boolean completed;

    public Task(String title, int priority) {
        this.title = title;
        this.priority = priority;
        this.completed = false;
    }

    public void markCompleted() {
        completed = true;
    }

    public int getPriority() {
        return priority;
    }

    public String getTitle() {
        return title;
    }

    public String toString() {
        return title + " | Priority: " + priority + " | Done: " + completed;
    }
}

Explanation:

• Fields are private → encapsulation
• Constructor initializes object state
• Getter methods allow safe access
• toString() defines how object is displayed

2️⃣ TaskManager.java

import java.util.ArrayList;
import java.io.FileWriter;
import java.io.IOException;

public class TaskManager {

    private ArrayList<Task> tasks;

    public TaskManager() {
        tasks = new ArrayList<>();
    }

    public void addTask(Task task) {
        tasks.add(task);
    }

    public void displayTasks() {
        for (int i = 0; i < tasks.size(); i++) {
            System.out.println(tasks.get(i));
        }
    }

    public Task findTask(String title) {
        for (int i = 0; i < tasks.size(); i++) {
            if (tasks.get(i).getTitle().equals(title)) {
                return tasks.get(i);
            }
        }
        return null;
    }

    public void sortByPriority() {

        for (int i = 0; i < tasks.size() - 1; i++) {

            for (int j = 0; j < tasks.size() - i - 1; j++) {

                if (tasks.get(j).getPriority() >
                    tasks.get(j + 1).getPriority()) {

                    Task temp = tasks.get(j);
                    tasks.set(j, tasks.get(j + 1));
                    tasks.set(j + 1, temp);
                }
            }
        }
    }

    public void saveToFile() {

        try {
            FileWriter writer = new FileWriter("tasks.txt");

            for (Task t : tasks) {
                writer.write(t.toString() + "\n");
            }

            writer.close();

        } catch (IOException e) {
            System.out.println("File error.");
        }
    }
}

Structure Explanation:

• ArrayList stores multiple Task objects
• findTask() uses linear search
• sortByPriority() uses bubble sort
• saveToFile() converts objects to text
• File logic is separated from Task class

3️⃣ Main.java

public class Main {

    public static void main(String[] args) {

        TaskManager manager = new TaskManager();

        manager.addTask(new Task("Math homework", 3));
        manager.addTask(new Task("Project", 1));
        manager.addTask(new Task("Gym", 5));

        System.out.println("Before sorting:");
        manager.displayTasks();

        manager.sortByPriority();

        System.out.println("After sorting:");
        manager.displayTasks();

        manager.saveToFile();
    }
}

Execution Flow:

1. Main starts program
2. Creates TaskManager
3. Creates Task objects
4. Stores tasks
5. Sorts tasks
6. Saves file

🎥 Final Submission – ManageBac

You must upload:

1. ZIP file of your Java project
2. 3–4 minute screen recording (MP4)

Video must include:

• Short explanation of UML
• Running program
• Sorting demonstration
• tasks.txt file
• Explanation of encapsulation
• Explanation of system structure

📝 Teacher Quick Evaluation

• Program runs
• Sorting works
• File created
• Student explains architecture
• Student understands class responsibilities