10.3. Writing the Program

// Employee.java
public class Employee {
    private int id;
    private String name;
    private String department;
    private double salary;
    public Employee(int id, String name, String department, double salary) {
        // Constructor
    }
    // Getters and Setters
}
// EmployeeManager.java
import java.util.*;
public class EmployeeManager {
    private List<Employee> employeeList = new ArrayList<>();
    public void addEmployee(Employee e) {
        employeeList.add(e);
    }
    public void deleteEmployee(int id) {
        // Remove logic
    }
    public Employee searchById(int id) {
        // Search logic
    }
}

This chunk introduces the creation of classes in Java that represent important entities in the Employee Management System. The Employee class contains attributes such as an ID, a name, a department, and a salary, which are critical characteristics of an employee. The constructor initializes these attributes when an object of the class is created. The EmployeeManager class manages a list of employees using methods to add, delete, and search employees by their ID. This structure helps us manage and manipulate employee data effectively.

Think of Employee as a blueprint for a physical object, like a car. Just as a car has properties (like make, model, and color), an Employee has properties (like ID, name, department, and salary). The EmployeeManager acts like a car dealership—keeping track of all the cars (employees) and allowing you to add new cars, remove them, or find a specific car based on its unique identifier (ID).

// FileHandler.java
import java.io.*;
public class FileHandler {
    public void saveToFile(List<Employee> employees) {
        // Write serialized list to file
    }
    public List<Employee> loadFromFile() {
        // Read from file and deserialize
    }
}

This chunk is about file handling in Java. The FileHandler class provides two methods: saveToFile and loadFromFile. The saveToFile method is responsible for saving the list of employees to a file, which means it will take the employee data and serialize it so that it can be stored on a disk. The loadFromFile method will read this file and deserialize the data back into Employee objects. This process is essential for data persistence, allowing the application to retain employee information even after it is closed.

Imagine you have a scrapbook where you keep pictures of all your friends—this scrapbook represents a file on your computer. The saveToFile method is like placing pictures into the scrapbook, ensuring they are stored safely away. When you want to look through your scrapbook again, the loadFromFile method acts like opening the scrapbook and flipping through the pages to find the pictures (employees) you saved before.

try {
    Employee e = manager.searchById(101);
    if (e == null) throw new Exception("Employee not found.");
} catch (Exception ex) {
    System.out.println("Error: " + ex.getMessage());
}

This chunk demonstrates how to handle exceptions in Java. The try block is used to attempt an operation that may fail—in this case, searching for an employee by ID. If the employee is not found, an Exception is thrown with a relevant message. The catch block catches this exception and prints out an error message, ensuring the program can handle the error gracefully without crashing. This approach improves reliability and user experience by providing meaningful feedback.

Think of this like trying to find a book in a library. You go to the shelf (the try block) looking for it, but if it's not there, you might be disappointed. Instead of just walking away, you can let the librarian know (the catch block), and they'll help you understand that the book is checked out or perhaps not available, thereby preventing your search from ending in confusion or frustration.

class AutoSaveThread extends Thread {
    public void run() {
        while (true) {
            try {
                Thread.sleep(60000); // save every minute
                // Trigger file save
            } catch (InterruptedException e) {
                // Handle
            }
        }
    }
}

In this chunk, a separate thread (AutoSaveThread) is created to perform the task of saving employee data automatically every minute. The run method contains a loop that pauses for 60 seconds (Thread.sleep(60000)) before executing the save function. Using multithreading allows the main program to continue running without blocking or waiting for the save process to complete. This enhances the user experience and ensures data is frequently saved without user intervention.

Imagine you are cooking dinner and your friend is setting the table at the same time. While you are focused on stirring the pot (main program), your friend is quietly arranging forks and plates (the autosave process) in the background. This way, when dinner is ready, everything is set up, and you didn’t have to stop cooking to prepare the dining area—just like the program continues to run while the autosave happens!

--