Classes and Objects

 4.3 Singleton Object

Scala cannot have static members. Instead, Scala has singleton objects. When a singleton object shares the same name with a class, it is called that class's companion object.You must define both the class and its companion object in the same source file. A class and its companion object can access each other's private members.. You can invoke methods on singleton objects using a similar syntax: the name of the singleton object, a dot, and the name of the method.A singleton object is more than a holder of static methods, however. It is a first-class object. Given each singleton object is an instance of its superclasses and mixed-in traits, you can invoke its methods via these types, refer to it from variables of these types, and pass it to methods expecting these types.One difference between classes and singleton objects is that singleton objects cannot take parameters, whereas classes can.A singleton object that does not share the same name with a companion class is called a standalone object. You can use standalone objects for many purposes, including collecting related utility methods together, or defining an entry point to a Scala application.

4.4 A Scala Application

To run a Scala program, you must supply the name of a standalone singleton object with a main method that takes one parameter, an Array[String], and has a result type of Unit. 

Note 

Scala implicitly imports members of packages java.lang and scala, as well as the members of a singleton object named Predef, into every Scala source file. Predef, which resides in package scala, contains many useful methods. 

you'll need to actually compile these files with the Scala compiler, then run the resulting class files. One way to do this is to use scalac, which is the basic Scala compiler, ike this:

  $ scalac ChecksumAccumulator.scala Summer.scala

This compiles your source files, but there may be a perceptible delay before the compilation finishes. The reason is that every time the compiler starts up, it spends time scanning the contents of  jar  files and doing other initial work before it even looks at the fresh source files you submit to it. For this reason, the Scala distribution also includes a Scala compiler  daemon  called  fsc  (for fast Scala compiler).  You use it like this:

  $ fsc ChecksumAccumulator.scala Summer.scala

The first time you run fsc, it will create a local server daemon attached to a port on your computer. It will then send the list of files to compile to the daemon via the port, and the daemon will compile the files. The next time you run fsc, the daemon will already be running, so fsc will simply send the file list to the daemon, which will immediately compile the files. Using fsc, you only need to wait for the Java runtime to startup the first time. If you ever want to stop the fsc daemon, you can do so with fsc -shutdown.

Running either of these scalac or fsc commands will produce Java class files that you can then run via the scala command, the same command you used to invoke the interpreter in previous examples. However, instead of giving it a filename with a .scala extension containing Scala code to interpret as you did in every previous example,[6] in this case you'll give it the name of a standalone object containing a main method of the proper signature. You can run the Summer application, therefore, by typing:

  $ scala Summer of love

4.5 The Application Trait

To use the trait, you first write "extends Application" after the name of your singleton object. Then instead of writing a main method, you place the code you would have put in themain method directly between the curly braces of the singleton object. That's it. You can compile and run this application just like any other.

Inheriting from  Application  is shorter than writing an explicit  main  method, but it also has some shortcomings. First, you can't use this trait if you need to access command-line arguments, because the  args  array isn't available. Second, because of some restrictions in the JVM threading model, you need an explicit main method if your program is multi-threaded.Finally, some implementations of the JVM do not optimize the initialization code of an object which is executed by the Application trait. So you should inherit from Application only when your program is relatively simple and single-threaded.