For classes with multiple constructors, which to choose as primary constructor?

[Scott Shipp]

I just swapped out a Java class in our code base for a Scala one. I ran into the following "problem." The Java class was basically a POJO with three constructors. There was a no-args constructor, a constructor with one arg, and a constructor with 22 args matching the 22 members of the class. The Scala approach that seems to be the most idiomatic is to choose the 22 arg constructor for the primary constructor. This allows (since most members were vals) the other constructors to call something like:

this(arg1, arg2, arg3 ...)

The thing, though, is that I don't like the readability here. "This" followed by 22 parameters most of which are null or false in this case seems like a recipe for future errors and it is impossible to tell easily what value is being passed for what member.

Is it better to make the no-arg constructor the primary? If so, with all the variables being vals, how do you create an auxiliary constructor that can write to val's from the auxiliary constructor? I think that trying to call this() and then trying to reassign to the val will trigger a compiler error.

Is there something else I'm not thinking of, that would make this code more maintainable?

[Jesper de Jong]

In Scala, the primary constructor is always called. Extra constructors must always contain a 'this(...)' call to call the primary constructor. So you must choose the constructors in such a way that this works out.

You cannot reassign a val - a val can be initialized once, and its value cannot be modified.

[Scott Shipp]

Thanks Jesper. This is such a strange language but a very cool one. What I found worked out for me was to use a combination of default parameters and named parameters.

Thus in the auxiliary constructors, when I called the default constructor, I could leave out passing all 22 arguments and focus on only those that were different.

Using fake code to illustrate:

class myClass(arg1: String = "", arg2: Boolean = false, arg3: someOtherObject = new someOtherObject, ..., arg22: yetAnotherObject = null) {

this(arg1: otherObject) {
  this(someOtherObject = arg1)
}

this(arg1: otherObject, arg2: yetAnotherObject) {
  this(someOtherObject = arg1, yetAnotherObject = arg2)
}