面向对象Java编程安全与静态工厂方法：添加Student对象至数组失败求助

Hey there! Let's figure out why your Student objects aren't being added to the array in ManagePeople when using static factory methods. Here are the key areas to check, step by step:

First, make sure your static factory method is properly returning a valid Student instance—this is critical for both security and functionality. A correct implementation should look something like this:

public class Student extends Person {
    // Keep constructor private to enforce use of factory method (per security requirements)
    private Student(String name, int age, String studentId) {
        super(name, age);
        // Initialize Student-specific fields here
    }

    // Static factory method to create Student instances
    public static Student createStudent(String name, int age, String studentId) {
        // Add security/validation checks here (e.g., non-empty student ID)
        if (studentId == null || studentId.isBlank()) {
            throw new IllegalArgumentException("Student ID cannot be empty or null!");
        }
        return new Student(name, age, studentId);
    }
}

Ensure the method isn't accidentally returning null, and that you're using this factory method exclusively to create Student objects (no direct instantiation via new Student(...)).

If your ManagePeople class uses an array of type Staff[] instead of Person[], you won't be able to add Student objects—this is a common type mismatch issue. Your array should be declared to hold the base Person type to support polymorphism:

public class ManagePeople {
    // Correct: Array of Person (can hold both Staff and Student)
    private Person[] peopleList = new Person[10];
    private int currentCount = 0;

    // Add method that accepts any Person subclass
    public void addPerson(Person person) {
        if (currentCount < peopleList.length) {
            peopleList[currentCount++] = person;
        } else {
            // Handle array overflow (e.g., resize the array)
            System.out.println("Error: People list is full!");
        }
    }
}

If you're using a Staff[] array, adding a Student will throw a compile-time or runtime ArrayStoreException.

It's easy to accidentally call the wrong factory method (e.g., a Person or Staff factory instead of Student's). Double-check your instantiation code:

// Correct: Use Student's static factory to create the instance
ManagePeople manager = new ManagePeople();
Student newStudent = Student.createStudent("Luna", 22, "STU-9876");
manager.addPerson(newStudent);

// Wrong: If you use a Person factory, you'll get a Person (not Student)
Person notAStudent = Person.createPerson("John", 30);
manager.addPerson(notAStudent); // This won't add a Student object

Verify that you're definitely calling Student.createStudent(...) to get your Student instance before passing it to addPerson.

If your addPerson method includes incorrect type casting (e.g., forcing all incoming Person objects to Staff), adding a Student will throw a ClassCastException and fail silently if you're not handling exceptions properly. Avoid this by keeping the method simple:

// Wrong: This will crash when adding a Student
public void addPerson(Person person) {
    Staff staffOnly = (Staff) person; // ClassCastException for Student
    peopleList[currentCount++] = staffOnly;
}

// Correct: No casting needed—accept any Person subclass
public void addPerson(Person person) {
    if (currentCount < peopleList.length) {
        peopleList[currentCount++] = person;
    }
}

If you're catching exceptions without logging or reporting them, you might not realize why the add operation is failing. For example:

// Bad practice: Swallowing exceptions hides errors
public void addPerson(Person person) {
    try {
        peopleList[currentCount++] = person;
    } catch (Exception e) {
        // No logging or feedback
    }
}

Add logging or error messages to catch blocks so you can see exactly what's going wrong when adding a Student.

内容的提问来源于stack exchange，提问作者Mercy Thomson