Java抽象类与具体类转换问题：工厂模式下ClassCastException报错

Hey there, let's break down this ClassCastException issue you're facing with your Factory Pattern implementation. From what you described, you've got an abstract class with overloaded factory methods spawning Admin and Student instances (both extending a User superclass), stored in an ArrayList<User>. When iterating to call class-specific methods, you're hitting that frustrating "can't cast Admin to Student" error—let's fix this.

Why This Happens #

Chances are, your iteration logic is skipping a critical step: checking the actual runtime type of each User instance before casting. For example, if you're doing something like this:

ArrayList<User> users = new ArrayList<>();
// Populate list with Admin and Student via factory methods

for (User user : users) {
    // This will blow up when user is an Admin!
    Student student = (Student) user;
    student.study();
}

You're forcing every element into a Student type, regardless of whether it's actually an Admin—hence the ClassCastException.

How to Fix It #

1. Add Safe Runtime Type Checks

Before casting, use instanceof to verify the instance's real type. This ensures you only cast when it's safe:

for (User user : users) {
    if (user instanceof Admin) {
        Admin admin = (Admin) user;
        admin.managePermissions(); // Call Admin-specific method
    } else if (user instanceof Student) {
        Student student = (Student) user;
        student.submitAssignment(); // Call Student-specific method
    }
}

If you're on Java 14 or later, you can simplify this with pattern matching for instanceof (no explicit casting needed):

for (User user : users) {
    if (user instanceof Admin admin) {
        admin.managePermissions();
    } else if (user instanceof Student student) {
        student.submitAssignment();
    }
}

2. (Optional) Refactor for Cleaner, More Maintainable Code

While the above fix works, relying on frequent type checks and casts can make your code brittle over time. A more OOP-aligned approach is to define an abstract method in the User superclass that each subclass implements with their own logic:

abstract class User {
    // Common user attributes/methods go here
    public abstract void performRoleTask();
}

class Admin extends User {
    @Override
    public void performRoleTask() {
        this.managePermissions();
    }

    private void managePermissions() {
        // Admin-only logic
    }
}

class Student extends User {
    @Override
    public void performRoleTask() {
        this.submitAssignment();
    }

    private void submitAssignment() {
        // Student-only logic
    }
}

Now your iteration becomes clean and cast-free—no more type checking needed:

for (User user : users) {
    user.performRoleTask(); // Automatically calls the correct subclass method
}

This follows the Liskov Substitution Principle and makes it easier to add new user types later without rewriting your iteration logic.

Quick Factory Method Sanity Check #

Just to rule out another edge case: double-check that your overloaded factory methods are returning the correct types. For example:

abstract class UserFactory {
    public static User createAdmin(String username) {
        return new Admin(username);
    }

    public static User createStudent(String username) {
        return new Student(username);
    }
}

As long as these methods are spawning the right subclass instances, the issue is definitely in your iteration logic's type handling.

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