Multiple Constructors

In Scala there is a primary constructor: class MyClass(constructorParam:Any). Unlike Java, that constructor must be called. The question that often arises is, "How can one define multiple constructors?" There is a simple way to do this, however often a factory companion object can be used to remove the need for multiple constructors. Factory Companion Objects are covered in a previous post but I will review the pattern here quickly.

First multiple constructors:

1. scala> class HelloConstructor(param1:Int, param2:Int) {
2.      | def this(onlyParam:Int) = this(onlyParam,onlyParam)
3.      | def this(p1:String, p2:String, p3:String) = this(p1.length, p2.length + p3.length)
4.      | def this(onlyParam:String) = this(onlyParam.length)
5.      | }
6. defined class HelloConstructor

In Java if a constructor calls another constructor that call must be the first statement in the constructor. Scala is the same except that in Scala the primary constructor must be called. Notice that all constructors call this(param1,param2) at some point. In addition any method defined in the class HelloConstructor is not available until after the primary constructor is invoked. The following examples are not valid.

1. scala> class HelloConstructor(param1:Int, param2:Int) {                                  
2.      | def x = 1
3.      | def this() = this(x,3)
4.      | }
5. <console>:6: error: not found: value x
6.        def this() = this(x,3)
8. scala> class HelloConstructor(param1:Int, param2:Int) {
9.      | def this() = {
10.      | println("constructing")  // the REPL won't even let me finish method definition
11. <console>:3: error: 'this' expected but identifier found.
12.        println("constructing")
13.        ^

Factory companion objects can be used to work around these restrictions:

1. scala> class HelloConstructor(param1:Int, param2:Int)  
2. defined class HelloConstructor
4. scala> object HelloConstructor {                             
5.      | def apply() = {
6.      | println("constructing object")
7.      | new HelloConstructor(1,2)
8.      | }
9.      | }
10. defined module HelloConstructor
12. scala> HelloConstructor()
13. constructing object
14. res1: HelloConstructor = HelloConstructor@5b0010ec

Since companion objects can access private members of the class the factory methods can be as powerful as a constructor without the restrictions.

One last idea that is useful when designing classes is Scala 2.8 default arguments:

1. scala> class HelloConstructor(param1: Int = 1, param2: Int = 2)
2. defined class HelloConstructor
4. scala> new HelloConstructor()
5. res0: HelloConstructor = HelloConstructor@7cd47880
7. scala> new HelloConstructor(1)
8. res1: HelloConstructor = HelloConstructor@3834a1c8
10. scala> new HelloConstructor(param1 = 1)
11. res2: HelloConstructor = HelloConstructor@3b3e3940
13. scala> new HelloConstructor(param2 = 1)
14. res3: HelloConstructor = HelloConstructor@6dee2ea8
16. scala> new HelloConstructor(3,4)       
17. res4: HelloConstructor = HelloConstructor@397b6074
19. scala> new HelloConstructor(param1 = 3, param2=4)
20. res5: HelloConstructor = HelloConstructor@20272fec

Factory Methods and Companion Objects

One of the most common uses of a companion object (See Companion Objects for more) is as a factory for creating instances of the class. For example, there may be several overloaded apply methods which provide different ways of instantiating the object. This is often preferred to adding many constructors because Scala places restrictions on constructors that Java does not have.

One built in example of Factory methods in a companion object are when you create a case class.

Examples:

1. scala> case class Data(p1:Int, p2:String)
2. defined class Data
4. // This is using the generated (or synthetic) factory method.
5. // call case classes have a factory method generated
6. scala> Data(1,"one")
7. res0: Data = Data(1,one)
9. // This is the normal new syntax.
10. // case-classes are normal object so they have one of these too
11. scala> new Data(1,"one")
12. res1: Data = Data(1,one)
14. scala> class MyClass(val p1:Int, val p2:String)
15. defined class MyClass
17. // MyClass is a normal class so there is no
18. // synthetic factory method
19. scala> MyClass(1,"one")
20. :5: error: not found: value MyClass
21.        MyClass(1,"one")
22.        ^
24. // but of course you can create an instance normally
25. scala> new MyClass(1,"one")
26. res3: MyClass = MyClass@55444319
28. // create the companion object with an apply factory method
29. scala> object MyClass{
30.      | def apply(p1:Int, p2:String)=new MyClass(p1,p2)
31.      | }
32. defined module MyClass
34. // now you can create MyClass as if it was a case-class
35. // It is not a case-class so you still don't have the other
36. // synthetic methods like: equals, hash-code, toString, etc...
37. scala> MyClass(1,"one")
38. res4: MyClass = MyClass@2c5e5c15

Companion Object

A companion object is an object with the same name as a class or trait and is defined in the same source file as the associated file or trait. A companion object differs from other objects as it has access rights to the class/trait that other objects do not. In particular it can access methods and fields that are private in the class/trait.

An analog to a companion object in Java is having a class with static methods. In Scala you would move the static methods to a Companion object.

One of the most common uses of a companion object is to define factory methods for class. An example is case-classes. When a case-class is declared a companion object is created for the case-class with a factory method that has the same signature as the primary constructor of the case class. That is why one can create a case-class like: MyCaseClass(param1, param2). No new element is required for case-class instantiation.

A second common use-case for companion objects is to create extractors for the class. I will mention extractors in a future topic. Basically extractors allow matching to work with arbitrary classes.

NOTE: Because the companion object and the class must be defined in the same source file you cannot create them in the interpreter. So copy the following example into a file and run it in script mode:

scala mysourcefile.scala


Example:

1. class MyString(val jString:String) {
2.   private var extraData = ""
3.   override def toString = jString+extraData
4. }
6. object MyString {
7.   def apply(base:String, extras:String) = {
8.     val s = new MyString(base)
9.     s.extraData = extras
10.     s
11.   }
12.   def apply(base:String) = new MyString(base)
13. }
15. println(MyString("hello"," world"))
16. println(MyString("hello"))