Singletons as Synthetic classes in Scala?

Question

I am reading Programming in Scala, and I don't understand the following sentence (pdf p.112):

Each singleton object is implemented as an instance of a synthetic class referenced from a static variable, so they have the same initialization semantics as Java statics.

Does this mean the if I have a singleton FooBar in scala, the compiler will create a class named FooBar$?

Also what does the author mean by "referenced from a static variable"? Is there a hidden static variable somewhere holding a reference to some FooBar$ class?

I appreciate any help here.

The trick is that the static variable references the instance, not the class. In other words, the Scala object `FooBar` is reference in Java as `FooBar$.MODULE$`. — Jesse Hallett, Apr 19 '11 at 19:03

score 26 · Accepted Answer · answered Apr 19 '11 at 18:57

The chapter 31 of the same "Programming in Scala" is more precise:

Java has no exact equivalent to a singleton object, but it does have static methods.

The Scala translation of singleton objects uses a combination of static and instance methods. For every Scala singleton object, the compiler will create a Java class for the object with a dollar sign added to the end.
For a singleton object named App, the compiler produces a Java class named App$.
This class has all the methods and fields of the Scala singleton object.
The Java class also has a single static field named MODULE$ to hold the one instance of the class that is created at run time.
As a full example, suppose you compile the following singleton object:

object App {
  def main(args: Array[String]) {
    println("Hello, world!")
  }
}

Scala will generate a Java App$ class with the following fields and methods:

$ javap App$
public final class App$ extends java.lang.Object
    implements scala.ScalaObject{
  public static final App$ MODULE$;
  public static {};
  public App$();
  public void main(java.lang.String[]);
  public int $tag();
}

That’s the translation for the general case.

Thanks that makes it clear. I guess I should've just skipped forward in the book :-) — Andriy Drozdyuk, Apr 19 '11 at 22:27
@ChristopherPerry `static {}` is a **static initialization block**, to initialize the singleton. See for instance http://stackoverflow.com/a/1836232/6309 or http://docs.oracle.com/javase/tutorial/java/javaOO/initial.html — VonC, Sep 07 '14 at 06:26

score 10 · Answer 2 · answered Apr 19 '11 at 18:54

You're basically correct.

If you have the singleton

object Singleton {
  def method = "Method result"
}

then compilation gives you

Singleton.class
Singleton$.class

and for the bytecode you find, first for Singleton:

public final class Singleton extends java.lang.Object{
public static final java.lang.String method();
  Signature: ()Ljava/lang/String;
  Code:
   0:   getstatic   #11; //Field Singleton$.MODULE$:LSingleton$;
   3:   invokevirtual   #13; //Method Singleton$.method:()Ljava/lang/String;
   6:   areturn
}

that is, a public static method for each method of the class that references something called Singleton$.MODULE$, and in Singleton$:

public final class Singleton$ extends java.lang.Object implements scala.ScalaObject{
public static final Singleton$ MODULE$;
  Signature: LSingleton$;

public static {};
  Signature: ()V
  Code:
   0:   new #9; //class Singleton$
   3:   invokespecial   #12; //Method "<init>":()V
   6:   return


public java.lang.String method();
  Signature: ()Ljava/lang/String;
  Code:
   0:   ldc #16; //String Method result
   2:   areturn


private Singleton$();
  Signature: ()V
  Code:
   0:   aload_0
   1:   invokespecial   #20; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   putstatic   #22; //Field MODULE$:LSingleton$;
   8:   return
}

Where you see that MODULE$ is what holds the instance of Singleton$, and method is just an ordinary method.

So, that's all there really is to it: create Singleton$ with a static field called MODULE$ to hold the unique instance of itself, populate that field, and then create a Singleton with static methods that forward all static calls to the appropriate methods from Singleton$.

Thanks, that is kind of clear, but what are the numbers 0 1 4 and so on? Sorry I am not intimately familiar with bytecode lol :( — Andriy Drozdyuk, Apr 19 '11 at 22:27
On the left, they're bytecode addresses. Line numbers, essentially. On the right, they refer to tables of classes, methods, fields, or whatever else is appropriate. — Rex Kerr, Apr 19 '11 at 22:35

Singletons as Synthetic classes in Scala?

2 Answers2

Linked