Question

I’m still trying to wrap my head around Scala constructors

public class MyClass {
    private String myString = null;

    public MyClass() {
        myString = "hello";
    }
} 

Answer 1

In Scala you would just do

class MyClass {
  private var myString = "hello"
}

This doesn’t look like the same thing, does it? But let’s look at the bytecode for what the Java code actually produces (let’s call that class JavaConstructor):

public JavaConstructor();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aconst_null
   6:   putfield    #2; //Field myString:Ljava/lang/String;
   9:   aload_0
   10:  ldc #3; //String hello
   12:  putfield    #2; //Field myString:Ljava/lang/String;
   15:  return

Java has effectively copied the private String myString = null; into the constructor (note lines 5 and 6 where null is created and stored). So that whole thing about setting myString to null was a complete waste of effort; you load it and then immediately overwrite it.

Now if we look at the corresponding Scala:

public ScalaConstructor();
  Code:
   0:   aload_0
   1:   invokespecial   #18; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   ldc #20; //String hello
   7:   putfield    #10; //Field myString:Ljava/lang/String;
   10:  return
}

we see it’s as efficient as one would hope (and reflects the code).

Then the question is: why might you want to do it the way you did in Java? Well, maybe you have multiple constructors and some of them will set myString and some won’t! Setting it to null is a way to remind yourself that you had better initialize it before you use it.

But Scala won’t let you do that. Scala really only allows one constructor; the others are just aliases that call that one constructor. You can make it private and load it up with lots of parameters if you need to, but the point is that having multiple constructors some of which set critical data and some of which do not is actually a rather failure-prone process. Better to do it just once, and write something like

private var myString = if (someParameter) "hello" else null

if you really need to do that. Then again, maybe you only made it a var because you were trying to set it differently in different constructors. With only one constructor, maybe there’s no need for that:

private val myString = if (someParameter) "hello" else null

But maybe now that it’s set correctly, we don’t really need it to be private.

val myString = if (someParameter) "hello" else null

and maybe if it often isn’t set, we should use an option instead:

val myString = if (someParameter) Some("hello") else None

and then you’d have something that looks more like idiomatic Scala.