Review and Refactor

public class CourseRoster {
    private String courseName;
    private Integer maxSize;
    private List<Student> enrolledStudents = new List<Student>();

    public CourseRoster(String courseName, Integer maxSize) {
        this.courseName = courseName;
        this.maxSize = maxSize;
    }

    public Boolean enroll(Student student) {
        if (student == null) {
            return false;
        }
        for (Student existing : enrolledStudents) {
            if (existing.getStudentId() == student.getStudentId()) {
                return false;
            }
        }
        if (enrolledStudents.size() >= maxSize) {
            return false;
        }
        enrolledStudents.add(student);
        return true;
    }

    public Integer getRemainingSeats() {
        return maxSize - enrolledStudents.size();
    }
}

1. public class CourseRoster { — the class, fields, and constructor — unchanged from the last two lessons. 2-9. Fields and constructor — same as before. 10-25. public Boolean enroll(Student student) { ... } — the exact same logic from "Add Business Rules" and "Handle Errors Gracefully," combined: a null check, a duplicate check, and a capacity check, all inline in one method body. 26-29. public Integer getRemainingSeats() { ... } — unchanged.
2. } — closes the class.

This works correctly — but enroll() is doing three separate jobs (null-check, duplicate-check, capacity-check) inline. That's a candidate for refactoring.

public class CourseRoster {
    private String courseName;
    private Integer maxSize;
    private List<Student> enrolledStudents = new List<Student>();

    public CourseRoster(String courseName, Integer maxSize) {
        this.courseName = courseName;
        this.maxSize = maxSize;
    }

    public Boolean enroll(Student student) {
        if (student == null || isAlreadyEnrolled(student) || isFull()) {
            return false;
        }
        enrolledStudents.add(student);
        return true;
    }

    private Boolean isAlreadyEnrolled(Student student) {
        for (Student existing : enrolledStudents) {
            if (existing.getStudentId() == student.getStudentId()) {
                return true;
            }
        }
        return false;
    }

    private Boolean isFull() {
        return enrolledStudents.size() >= maxSize;
    }

    public Integer getRemainingSeats() {
        return maxSize - enrolledStudents.size();
    }
}

1. public class CourseRoster { — the class.
2. private String courseName; — unchanged.
3. private Integer maxSize; — unchanged.
4. private List<Student> enrolledStudents = new List<Student>(); — unchanged.
5. (blank line)
6. public CourseRoster(String courseName, Integer maxSize) { — unchanged.
7. this.courseName = courseName; — unchanged.
8. this.maxSize = maxSize; — unchanged.
9. } — closes the constructor.
10. (blank line)
11. public Boolean enroll(Student student) { — now reads almost like a sentence.
12. if (student == null || isAlreadyEnrolled(student) || isFull()) { — reject if null, already enrolled, or full — each condition delegated to a named method instead of written out inline.
13. return false; — rejects.
14. } — closes the if.
15. enrolledStudents.add(student); — otherwise, add.
16. return true; — reports success.
17. } — closes enroll().
18. (blank line)
19. private Boolean isAlreadyEnrolled(Student student) { — private — an internal implementation detail, not part of the class's public contract.
20. for (Student existing : enrolledStudents) { — the same loop as before, now living in its own named method.
21. if (existing.getStudentId() == student.getStudentId()) { — same check.
22. return true; — signals a match.
23. } — closes the if.
24. } — closes the loop.
25. return false; — no match found.
26. } — closes the method.
27. (blank line)
28. private Boolean isFull() { — another private internal detail.
29. return enrolledStudents.size() >= maxSize; — the same capacity check, now named.
30. } — closes the method.
31. (blank line)
32. public Integer getRemainingSeats() { — unchanged, still public.
33. return maxSize - enrolledStudents.size(); — unchanged.
34. } — closes the method.
35. } — closes the class.

External behavior hasn't changed at all — every existing call to enroll() behaves identically.

Getting something working first, then reviewing it with fresh eyes, is the normal shape of real development — not a sign the first version was wrong. A method with three unrelated checks jammed together isn't a bug, but it is harder to read, test, and extend than three named, focused pieces. Refactoring after it works, rather than trying to write the "perfect" version first, keeps each step small and verifiable.