refactor: Apply SRP by separating concerns into distinct classes

This commit refactors the task tracker application to adhere to the
Single Responsibility Principle (SRP). The original single-file or
less structured code has been broken down into four distinct classes,
each with a single, well-defined responsibility:

- Task.java: Represents the Task data model, encapsulating task
  description and completion status. Its sole responsibility is to
  hold task information.

- Task_Tracker.java: Manages the collection of Task objects. Its
  responsibilities are purely related to business logic: adding tasks,
  marking tasks as complete, and providing access to task data.
  Console output has been removed from this class.

- TaskConsoleView.java: Handles all console-based user interface
  interactions related to output. This includes displaying the menu,
  rendering the task list, and showing informational messages or prompts.

- TaskTrackerApp.java: Serves as the application's entry point and
  controller. It manages the main application loop, handles user input
  (via Scanner), and orchestrates the interactions between the
  TaskTracker (model) and TaskConsoleView (view).

This separation improves code modularity, enhances testability for each
component, and increases maintainability by ensuring that changes to
one aspect (e.g., UI presentation) are less likely to impact other
unrelated aspects (e.g., task management logic).

Author: titan2903

Task_Tracker/Task.java

@@ -0,0 +1,31 @@
+package Task_Tracker;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Task {
+    private String description;
+    private boolean completed;
+
+    public Task(String description) {
+        this.description = description;
+        this.completed = false;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public boolean isCompleted() {
+        return completed;
+    }
+
+    public void markCompleted() {
+        completed = true;
+    }
+
+    // For easier debugging or direct object printing if needed elsewhere
+    @Override
+    public String toString() {
+        return description + (completed ? " - Completed" : "");
+    }
+}

Task_Tracker/TaskConsoleView.java

@@ -0,0 +1,41 @@
+package Task_Tracker;
+import java.util.List;
+
+public class TaskConsoleView {
+
+    // Responsibility: Display the list of tasks.
+    public void displayTasks(List<Task> tasks) {
+        System.out.println("\nTask List:");
+        if (tasks.isEmpty()) {
+            System.out.println("No tasks available.");
+            return;
+        }
+        for (int i = 0; i < tasks.size(); i++) {
+            Task task = tasks.get(i);
+            // Using getDescription() and isCompleted() from Task object
+            System.out.println((i + 1) + ". " + task.getDescription() +
+                    (task.isCompleted() ? " - Completed" : ""));
+        }
+    }
+
+    // Responsibility: Display the application menu.
+    public void displayMenu() {
+        System.out.println("\n1. Add Task\n2. Mark Task as Completed\n3. Display Tasks\n4. Exit");
+        System.out.print("Choose an option: ");
+    }
+
+    // Responsibility: Display a generic message.
+    public void showMessage(String message) {
+        System.out.println(message);
+    }
+
+    // Responsibility: Return the prompt string for task description.
+    public String getTaskDescriptionPrompt() {
+        return "Enter task description: ";
+    }
+
+    // Responsibility: Return the prompt string for task index.
+    public String getTaskIndexPrompt() {
+        return "Enter the index of the task to mark as completed: ";
+    }
+}

Task_Tracker/TaskTrackerApp.java

@@ -0,0 +1,87 @@
+package Task_Tracker;
+import java.util.Scanner;
+import java.util.List;
+
+public class TaskTrackerApp {
+    public static void main(String[] args) {
+        TaskTracker taskTracker = new TaskTracker();
+        TaskConsoleView taskView = new TaskConsoleView();
+        Scanner scanner = new Scanner(System.in); // Input handling primarily here
+
+        while (true) {
+            taskView.displayMenu();
+
+            int choice = -1;
+            if (scanner.hasNextInt()) {
+                choice = scanner.nextInt();
+            } else {
+                taskView.showMessage("Invalid input. Please enter a number.");
+                scanner.next(); // Consume invalid input
+                continue; // Go back to the start of the loop
+            }
+            scanner.nextLine(); // Consume the newline character
+
+            switch (choice) {
+                case 1:
+                    taskView.showMessage(taskView.getTaskDescriptionPrompt()); // Show prompt via view
+                    String description = scanner.nextLine();
+                    if (taskTracker.addTask(description)) {
+                        taskView.showMessage("Task added: " + description);
+                    } else {
+                        // This case might be relevant if addTask could fail for other reasons in a more complex app
+                        taskView.showMessage("Failed to add task.");
+                    }
+                    break;
+
+                case 2:
+                    if (taskTracker.getTasks().isEmpty()) {
+                        taskView.showMessage("No tasks to mark. Add a task first.");
+                        break;
+                    }
+                    taskView.showMessage(taskView.getTaskIndexPrompt()); // Show prompt via view
+                    int indexToMarkInput = -1;
+                    if (scanner.hasNextInt()) {
+                        indexToMarkInput = scanner.nextInt();
+                        scanner.nextLine(); // Consume newline
+
+                        int actualIndex = indexToMarkInput - 1; // Adjust for 0-based indexing
+                        Task taskToMark = taskTracker.getTask(actualIndex);
+
+                        if (taskToMark != null) { // Check if task exists at index
+                            if (taskToMark.isCompleted()){
+                                taskView.showMessage("Task '" + taskToMark.getDescription() + "' is already completed.");
+                            } else {
+                                if (taskTracker.markTaskCompleted(actualIndex)) {
+                                    taskView.showMessage("Task marked as completed: " + taskToMark.getDescription());
+                                } else {
+                                    // This path should ideally not be hit if getTask returned non-null
+                                    // and markTaskCompleted only fails on bad index, which we checked.
+                                    // Kept for robustness in case logic changes.
+                                    taskView.showMessage("Failed to mark task as completed.");
+                                }
+                            }
+                        } else {
+                            taskView.showMessage("Invalid task index.");
+                        }
+                    } else {
+                        taskView.showMessage("Invalid input for index. Please enter a number.");
+                        if(scanner.hasNextLine()) scanner.nextLine(); // Consume invalid input
+                    }
+                    break;
+
+                case 3:
+                    taskView.displayTasks(taskTracker.getTasks());
+                    break;
+
+                case 4:
+                    taskView.showMessage("Exiting the Task Tracker. Goodbye!");
+                    scanner.close(); // Close scanner on exit
+                    System.exit(0);
+                    break; // Not strictly necessary after System.exit(0) but good practice
+
+                default:
+                    taskView.showMessage("Invalid choice. Please choose a valid option.");
+            }
+        }
+    }
+}

Task_Tracker/Task_Tracker.java

@@ -1,97 +1,46 @@
+package Task_Tracker;
 import java.util.ArrayList;
-import java.util.Scanner;
+import java.util.List;
+import java.util.Collections;
 
-class Task {
-    private String description;
-    private boolean completed;
-
-    public Task(String description) {
-        this.description = description;
-        this.completed = false;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public boolean isCompleted() {
-        return completed;
-    }
-
-    public void markCompleted() {
-        completed = true;
-    }
-}
-
-class TaskTracker {
+public class TaskTracker {
     private ArrayList<Task> tasks;
 
     public TaskTracker() {
         tasks = new ArrayList<>();
     }
 
-    public void addTask(String description) {
+    // Responsibility: Add a task to the list.
+    // Returns true if added successfully.
+    public boolean addTask(String description) {
         Task newTask = new Task(description);
         tasks.add(newTask);
-        System.out.println("Task added: " + description);
+        return true;
     }
 
-    public void markTaskCompleted(int index) {
+    // Responsibility: Mark a task as completed.
+    // Returns true if task was found and marked, false otherwise.
+    public boolean markTaskCompleted(int index) {
         if (index >= 0 && index < tasks.size()) {
             Task task = tasks.get(index);
             task.markCompleted();
-            System.out.println("Task marked as completed: " + task.getDescription());
-        } else {
-            System.out.println("Invalid task index.");
+            return true;
         }
+        return false;
     }
 
-    public void displayTasks() {
-        System.out.println("Task List:");
-        for (int i = 0; i < tasks.size(); i++) {
-            Task task = tasks.get(i);
-            System.out.println((i + 1) + ". " + task.getDescription() +
-                    (task.isCompleted() ? " - Completed" : ""));
-        }
+    // Responsibility: Provide access to the list of tasks.
+    // Returns an unmodifiable list to prevent external modification.
+    public List<Task> getTasks() {
+        return Collections.unmodifiableList(tasks); // Return a read-only view
     }
-}
-
-public class TaskTrackerApp {
-    public static void main(String[] args) {
-        TaskTracker taskTracker = new TaskTracker();
-        Scanner scanner = new Scanner(System.in);
-
-        while (true) {
-            System.out.println("\n1. Add Task\n2. Mark Task as Completed\n3. Display Tasks\n4. Exit");
-            System.out.print("Choose an option: ");
-
-            int choice = scanner.nextInt();
-            scanner.nextLine(); // Consume the newline character
-
-            switch (choice) {
-                case 1:
-                    System.out.print("Enter task description: ");
-                    String description = scanner.nextLine();
-                    taskTracker.addTask(description);
-                    break;
 
-                case 2:
-                    System.out.print("Enter the index of the task to mark as completed: ");
-                    int index = scanner.nextInt();
-                    taskTracker.markTaskCompleted(index - 1); // Adjust index for user input
-                    break;
-
-                case 3:
-                    taskTracker.displayTasks();
-                    break;
-
-                case 4:
-                    System.out.println("Exiting the Task Tracker. Goodbye!");
-                    System.exit(0);
-
-                default:
-                    System.out.println("Invalid choice. Please choose a valid option.");
-            }
+    // Responsibility: Get a specific task by index.
+    // Returns the Task object or null if index is invalid.
+    public Task getTask(int index) {
+        if (index >= 0 && index < tasks.size()) {
+            return tasks.get(index);
         }
+        return null;
     }
-}
+}