Java中抽象类的getData()方法需支持有无参数多场景，该如何合理实现？

方案1：泛型化抽象类+参数上下文（推荐，适配所有参数场景） #

对原有抽象类做双泛型改造，分别定义返回数据类型和参数类型，无参场景直接用Void作为参数类型占位即可，完全不会让无参实现类多实现冗余方法：

改造后的抽象类定义 #

public interface DataExporter {
    MultipartFile export() throws IOException;
}

// 新增第二个泛型P，代表getData方法的入参类型
public abstract class AbstractExporter<T, P> implements DataExporter {
    protected abstract Iterable<T> getData(P param);
}

无参场景实现（原EmployeeExporter无需额外逻辑） #

public class EmployeeExporter extends AbstractExporter<EmployeeDTO, Void> {
    @Override
    protected Iterable<EmployeeDTO> getData(Void unused) {
        // 原有逻辑即可，无需处理入参
    }

    @Override
    public MultipartFile export() throws IOException {
        // 调用getData直接传null
        Iterable<EmployeeDTO> data = getData(null);
        // 原有导出逻辑
    }
}

单参数场景实现 #

public class ManagerExporter extends AbstractExporter<ManagerDTO, UUID> {
    @Override
    protected Iterable<ManagerDTO> getData(UUID uuid) {
        // 原有带参逻辑
    }

    @Override
    public MultipartFile export() throws IOException {
        // 参数可以从构造器注入/当前上下文获取
        UUID uuid = getQueryUuid();
        Iterable<ManagerDTO> data = getData(uuid);
        // 导出逻辑
    }
}

多参数场景实现 #

不需要用Object[]，直接自定义参数封装类（Java 16+可用record简化定义）即可，类型安全且参数语义清晰：

// 自定义参数封装类，所有参数语义明确
public record ManagerQueryParam(UUID uuid, UUID departmentUuid, UUID staffUuid) {}

// 对应导出器实现
public class ManagerExporter extends AbstractExporter<ManagerDTO, ManagerQueryParam> {
    @Override
    protected Iterable<ManagerDTO> getData(ManagerQueryParam param) {
        // 直接从param中取对应参数即可，无需强转
        return managerService.list(param.uuid(), param.departmentUuid(), param.staffUuid());
    }

    @Override
    public MultipartFile export() throws IOException {
        ManagerQueryParam param = new ManagerQueryParam(xxx, xxx, xxx);
        Iterable<ManagerDTO> data = getData(param);
        // 导出逻辑
    }
}

该方案的优势：

• 完全类型安全，编译期即可校验参数类型，不会出现运行时类型转换异常
• 无参、多参场景完全兼容，无需修改上层抽象定义
• 参数语义清晰，后续扩展参数只需要新增/修改参数类即可，维护成本极低

方案2：构造器注入参数（兼容原有抽象类，无需修改上层定义） #

如果你的参数在导出器实例化时就可以确定，不需要动态传入，可以直接用构造器注入参数，完全不用修改原有抽象类的getData签名：

public class ManagerExporter extends AbstractExporter<ManagerDTO> {
    // 所有需要的参数作为成员变量
    private final UUID uuid;
    private final UUID departmentUuid;

    // 实例化时传入参数
    public ManagerExporter(UUID uuid, UUID departmentUuid) {
        this.uuid = uuid;
        this.departmentUuid = departmentUuid;
    }

    @Override
    protected Iterable<ManagerDTO> getData() {
        // 直接使用成员变量参数即可，完全适配原抽象类的无参方法定义
        return managerService.list(uuid, departmentUuid);
    }

    @Override
    public MultipartFile export() throws IOException {
        Iterable<ManagerDTO> data = getData();
        // 导出逻辑
    }
}

关于是否使用Object[]传参的问题 #

强烈不推荐使用Object[]传参，弊端非常明显：

• 没有类型校验，所有参数都需要强转，容易出现运行时异常
• 参数语义不明确，后续维护时需要逐个对应参数位置，非常容易出错
• 扩展性差，新增/删除参数都需要修改所有调用处的参数顺序

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