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