如何从重载的可变参数构造函数调用基构造函数？

问题背景 #

我有一个包含全参构造函数的简单类FooClass，希望添加一个重载的可变参数（varargs）构造函数，以便在部分字段未知的情况下也能创建对象。

原代码如下：

class FooClass {
    int id;
    String first;
    String second;
    String third;

    FooClass(final int id, final String first, final String second, final String third) {
        this.id = id;
        this.first = first;
        this.second = second;
        this.third = third;
    }

    FooClass(final int id, final String... myStrings){
        if(myStrings.length == 1) {
            this.id     = id;
            this.first  = myStrings[0];
        } else if (myStrings.length == 2) {
            this.id     = id;
            this.first  = myStrings[0];
            this.second = myStrings[1];
        } else {
            this.id     = id;
            this.first  = myStrings[0];
            this.second = myStrings[1];
            this.third  = myStrings[2];
        }
    }
}

为避免重复编写this.id, this.first...等代码，我尝试对第二个构造函数进行重构，却出现编译错误：

FooClass(final int id, final String... myStrings){
        if(myStrings.length == 1) {
            this(id, myStrings[0], null, null);
        } else if (myStrings.length == 2) {
            this(id, myStrings[0], myStrings[1], null);
        } else {
            this(id, myStrings[0], myStrings[1], myStrings[2]);
        }
    }

错误提示：

Call to 'this()' must be first statement in constructor body

请问如何正确地从可变参数构造函数传入null值调用基构造函数？或者有更优的实现方案吗？

解决方法 #

1. 符合语法规则的直接重构 #

Java强制要求构造函数中调用this()必须是第一条语句，不能放在分支判断里。我们可以提前计算好要传入的参数，在第一行调用全参构造：

FooClass(final int id, final String... myStrings) {
    this(
        id,
        myStrings.length >= 1 ? myStrings[0] : null,
        myStrings.length >= 2 ? myStrings[1] : null,
        myStrings.length >= 3 ? myStrings[2] : null
    );
}

这段代码的逻辑和你原有的分支判断完全一致，同时避免了重复赋值。如果需要处理myStrings长度超过3的情况，可以在调用this()前添加校验，比如：

FooClass(final int id, final String... myStrings) {
    if (myStrings.length > 3) {
        throw new IllegalArgumentException("最多只能传入3个字符串参数");
    }
    this(
        id,
        myStrings.length >= 1 ? myStrings[0] : null,
        myStrings.length >= 2 ? myStrings[1] : null,
        myStrings.length >= 3 ? myStrings[2] : null
    );
}

2. 更优实现：Builder模式 #

如果你的类字段较多，或者未来可能扩展字段，可变参数构造函数的可读性会很差（调用者很难记住参数对应的是哪个字段）。这种情况下，Builder模式是更优雅的选择：

class FooClass {
    int id;
    String first;
    String second;
    String third;

    // 私有构造，只能通过Builder实例创建对象
    private FooClass(Builder builder) {
        this.id = builder.id;
        this.first = builder.first;
        this.second = builder.second;
        this.third = builder.third;
    }

    // 静态内部Builder类
    public static class Builder {
        private final int id; // id为必填字段
        private String first;
        private String second;
        private String third;

        public Builder(int id) {
            this.id = id;
        }

        public Builder first(String first) {
            this.first = first;
            return this;
        }

        public Builder second(String second) {
            this.second = second;
            return this;
        }

        public Builder third(String third) {
            this.third = third;
            return this;
        }

        // 构建并返回FooClass实例
        public FooClass build() {
            return new FooClass(this);
        }
    }
}

使用方式非常直观，调用者可以清晰地设置需要的字段：

// 创建只设置id和first的对象
FooClass foo1 = new FooClass.Builder(1).first("hello").build();
// 创建设置所有字段的对象
FooClass foo2 = new FooClass.Builder(2).first("a").second("b").third("c").build();

Builder模式的优势：

• 可读性极强，通过方法名明确知道设置的是哪个字段
• 支持灵活组合字段，不需要维护多个重载构造函数
• 扩展新字段时只需在Builder中添加对应方法，不用修改现有代码，符合开闭原则

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