Danger: Shadowed member values

It is possible (although not recommended) to declare a public property in a super class and have a private value or variable in a subclass:

1. scala> class X (val i:Int)
2. defined class X
4. scala> class Y(i:Int) extends X(19) {
5.      | println(i)
6.      | }
7. defined class Y
9. scala> val y = new Y(100)
10. 100
11. y: Y = Y@3e55a58f
13. scala> y.i
14. res7: Int = 19

This begs the question: how can the subclass access the superclass instance of i? Let me re-iterate. Just because it is possible this is a bad idea. This pattern seems like it is begging to create bugs. But who knows there is probably some reason out there where this is required.

The way to access the X.i value from Y is to declare which value you want using the syntax this:X :

1. scala> class Y(i:Int) extends X(19) {
2.      | println("Y.i"+i)              
3.      | println("X.i"+(this:X).i)
4.      | }
5. defined class Y
7. scala> new Y(39)
8. Y.i39
9. X.i19
10. res8: Y = Y@451dfada

Repeat: Watch out! Because I learned this danger while writing this topic:

1. scala> class Y(i:Int) extends X(19) {
2.      | println("1. "+i)              
3.      | println("2. "+this.i)         
4.      | println("3. "+(this:Y).i)     
5.      | println("4. "+(this:X).i)     
6.      | }
7. defined class Y
9. scala> new Y(44)
10. 1. 44
11. 2. 44
12. 3. 19  // this is created via (this:Y).i !
13. 4. 19
14. res0: Y = Y@338bd37a

It seems that the syntax (this:X).i accesses the public accessor for i. The public access is a method call I think so it always obtains the value for the property. Shocking!

Access modifiers (public, private, protected)

By default classes, objects and class members (fields, methods) are all public.
IE:

1. object PublicObject {
2.   val publicVal
3.   var publicVar
4.   def publicMethod = 1
5. }

In this example everything is public. Similar to Java there is private and protected (there is no public because that is default). Private works as it does in Java but protected is dramatically different.

• The first difference is that protected can have two forms: protected and protected[foo]. Where foo can be a class, package or object.


• The second difference is that the non-parameterized protected for is only visible from subclasses not from the same package.

1. scala> class Class1 {
2.      | protected def pMethod = "protected"
3.      | }
4. defined class Class1
6. scala> class Class2 { 
7. // pMethod is not accessible because Class2 is not a subclass of Class1
8.      | new Class1().pMethod 
9.      | }
10. <console>:6: error: method pMethod cannot be accessed in Class1
11.        new Class1().pMethod
12.                     ^
14. scala> class Class3 extends Class1 {
15. // also unlike Java, protected restricts to the same object
16.      | new Class1().pMethod
17.      | }
18. <console>:6: error: method pMethod cannot be accessed in Class1
19.        new Class1().pMethod
20.                     ^
22. scala> class Class3 extends Class1 {
23.      | pMethod
24.      | }
25. defined class Class3

If the protected is parameterized then only classes that fall into the parameter category can access the parameter:

1. scala> class Class1 {                                
2. // protected[Class1] is equivalent to private
3.      | protected[Class1] def method() = println("hi")
4.      | method()
5.      | }
6. defined class Class1
8. scala> new Class1()
9. hi
10. res0: Class1 = Class1@dc44a6d
12. // this does not work because method is only accessible in Class1
13. scala> class Class2 extends Class1 { method() }      
14. <console>:5: error: not found: value method
15.        class Class2 extends Class1 { method() }
16.                                      ^
17. scala> object Module {                                         
18.      |   object Inner1 {                                         
19.      |     protected[Inner1] def innerMethod = println("hi")       
20.      |     protected[Module] def moduleMethod = println("moduleMethod")
21.      |
22.      |     object InnerInner { 
23.      |       // InnerInner is within Inner1 so the access works
24.      |       def callInner = innerMethod
25.      |     }
26.      |   }
27.      |   // module method is protected[Module] so anything in Module can access it
28.      |   def callModuleMethod = Inner1.moduleMethod
29.      |
30.      |   object Inner2 {
31.      |     // Inner1.module method is protected[Module] and 
32.      |     // Inner2 is within module so therefore has access
33.      |     def callModuleMethod = Inner1.moduleMethod
34.      |   }
35.      | }
36. defined module Module
38. scala> Module.callModuleMethod
39. moduleMethod
41. scala> Module.Inner1.InnerInner.callInner
42. hi
44. scala> Module.Inner1.innerMethod         
45. <console>:6: error: method innerMethod cannot be accessed in object Module.Inner1
46.        Module.Inner1.innerMethod
47.                      ^
49. scala> Module.Inner1.moduleMethod
50. <console>:6: error: method moduleMethod cannot be accessed in object Module.Inner1
51.        Module.Inner1.moduleMethod

The following example shows how package access works in Scala 2.8. They have to be compiled as 2 files.

Root.scala:

1. package root
3. class Class1 {
4.   protected[root] def rootMethod = println("rootMethod")
5. }
7. class Class2 {
8.   // same package so this is legal
9.   new Class1().rootMethod
10. }

Subpackage.scala

1. package root.sub
3. class Class3 {
4.   // Class3 is in a subpackage of root so 
5.   // it can access all objects protected by
6.   // protected[root] as well as objects
7.   // protected by protected[root.sub]
8.   new root.Class1().rootMethod
9. }

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

Apply-update methods

The apply and update methods have special meaning in Scala. They allow a developer to define semantics like java array access for an arbitrary class. For example:

1. scala> class Phonebook {
2.      |  val numbers = scala.collection.mutable.Map[String,String]()
3.      | def apply(name:String):String = numbers(name)
4.      | def update(name:String, number:String) = numbers(name) = number
5.      | }
6. defined class Phonebook
8. scala> val book = new Phonebook() 
9. book: Phonebook = Phonebook@1e406b09
11. scala> book("jesse") = "123 456 7890" 
13. scala> println (book("jesse"))
14. 123 456 7890

As you can see you can invoke the apply method in a similar way that [] are used on arrays in Java. When you call 'obj(param)' the call is translated by the compiler to: 'obj.apply(param)'. As such apply can have any number of arguments.

Similarly 'obj(param) = value' is compiled to 'obj.update(param,value)'. Again the update method can have as many arguments as you wish. However only the last argument is treated as a value. So:

1. scala> class Echo {
2.      | def update(n:String, n2:String, n3:String ) = println(n,n2,n3)
3.      | }
4. defined class Echo
6. scala> val e = new Echo()
7. e: Echo = Echo@2fa847df
9. scala> e("hello", "hi") = "bonjour"
10. (hello,hi,bonjour)
12. scala> e("hello") = ("salut","bonjour")
13. :7: error: wrong number of arguments for method update: (String,String,String)Unit
14.        e("hello") = ("salut","bonjour")
15.                   ^

This makes sense because if apply has many arguments representing the key then the same key must work for the update method for assignment. If you have many values to assign try:

1. scala> class Phonebook {
2.      |  val numbers = scala.collection.mutable.Map[String, (Int, Int)]()
3.      | def apply(name:String) = numbers(name)
4.      | def update(name:String, number:(Int,Int)) = numbers(name) = number
5.      | }
6. defined class Phonebook
8. scala> val book2 = new Phonebook()
9. book2: Phonebook = Phonebook@7a120cb3
11. scala> book2("jesse") = (123, 4567890)
13. scala> val (areaCode, local) = book2("jesse")
14. areaCode: Int = 123
15. local: Int = 4567890

Traits and inheritance

Scala provides two structures for inheritance. Classes (abstract or not) and traits. Traits are very similar to Ruby Mixins meaning that they can contain code like abstract classes but like interfaces multiple traits can be inherited from.
Like interfaces traits cannot have constructors but in Scala variables can be abstract and therefore provide an easy way to simulate a constructor.
There are no method resolution conflicts because method definitions are always resolved right to left:

1. class X extends Y with A with B with C

If ABC and Y all have the method (doit) the method in C will be used. If C calls super.doit that will call B.doit and so on.
Note: If Y defines doit the A, B, and C must define doit with the override keyword:

1. override def doit() = {...}

In the above example ABC must be traits but Y can be a class or a trait. When inheriting you must always have one extends keyword which can optionally followed by one or more with clauses.

1. scala> abstract class Animal {
2.      |  val legs:Int
3.      | val noise:String
4.      | def makeNoise() = println(noise)
5.      | }
6. defined class Animal
8. scala>  trait Quadriped {
9.      | self:Animal =>
10.      | val legs = 4
11.      | }
12. defined trait Quadriped
14. scala> trait Biped {
15.      | self:Animal =>
16.      | val legs = 2
17.      | }
18. defined trait Biped
20. scala> class Dog extends Animal with Quadriped {
21.      | val noise = "Woof"
22.      | override def makeNoise() = println( noise+" "+noise)
23.      | }
24. defined class Dog
26. scala> new Dog().makeNoise()
27. Woof Woof
29. scala> abstract class GenericAnimal extends Animal{ 
30.      | val noise = "glup"                          
31.      | }
32. defined class GenericAnimal
34. scala> val quad = new GenericAnimal() with Quadriped
35. quad: GenericAnimal with Quadriped = $anon$1@10bfb545
37. scala> quad.makeNoise()
38. glup
40. scala> val biped = new GenericAnimal() with Biped
41. biped: GenericAnimal with Biped = $anon$1@7669521
43. scala> val biped = new GenericAnimal() with Biped{
44.      | override val noise = "Hello"
45.      | }
46. biped: GenericAnimal with Biped = $anon$1@6366ce5f
48. scala> biped.makeNoise()
49. Hello

Case classes

Case classes are a special type of class that comes with several convenient definitions (equals, hashCode, toString, copy). There are two main uses:

1. Data object
2. Matching

First examples is using as a datastructure (Note: Some and None are both case classes):

1. scala> val tree = Node( "root",
2.      |                  Some(Node( "left", None, None)),
3.      |                  Some(Node( "right", None, Some( Node( "grandchild", None, None) ) ) )
4.      |                )
5. tree: Node = Node(root,Some(Node(left,None,None)),Some(Node(right,None,Some(Node(grandchild,None,None)))))
7. // you can deconstruct a datastructure made of cases classes
8. scala> tree match {
9.      | case Node( _, Some(left), Some(right) ) => println(left, right)
10.      | case _ => println( "shouldnt happen" )
11.      | }
12. (Node(left,None,None),Node(right,None,Some(Node(grandchild,None,None))))
14. scala> case class DataStructure( value1:String, value2:Int, value3:String)
15. defined class DataStructure
17. scala>  val d = DataStructure("one", 2, "three")
18. d: DataStructure = DataStructure(one,2,three)
20. scala> d.toString
21. res0: String = DataStructure(one,2,three)
23. scala> d == DataStructure("one", 2, "three")
24. res1: Boolean = true
26. scala> d == DataStructure("zero",1, "two")
27. res2: Boolean = false
29. scala> d.hashCode
30. res4: Int = 1652907895
32. // Only available in Scala 2.8
33. scala> d.copy( value3="newValue")
34. res5: DataStructure = DataStructure(one,2,newValue)

Simple classes

Scala classes are similar to java classes but are designed to work around some of the boiler plate code. We will address multiple constructors another day. But one thing to note is that normally the code that is in a Java constructor goes directly in the body of a Scala class or in a companion object (also covered later).

1. scala> class NewClass( aPrivateInt:Int, val iAmPublic:Int, var iAmAlsoPublic:Int)
2. defined class NewClass
4. scala> val c = new NewClass(1,2,3)
5. c: NewClass = NewClass@da99836
7. scala> c.aPrivateInt
8. :7: error: value aPrivateInt is not a member of NewClass
9.        c.aPrivateInt
10.          ^
12. scala> c.iAmPublic
13. res2: Int = 2
15. scala> c.iAmAlsoPublic
16. res3: Int = 3
18. scala> c.iAmPublic = 10 // not allowed because iAmPublic is a val
19. :6: error: reassignment to val
20.        c.iAmPublic = 10
21.                    ^
23. scala> c.iAmAlsoPublic = 10 // iAmAlsoPublic is a var
25. scala> c.iAmAlsoPublic
26. res4: Int = 10
28. scala> class c2( aPrivate:Int ) {
29.      | val aPublic = aPrivate + 10
30.      | }
31. defined class c2
33. scala> class c3(tmp:Int) extends c2(tmp){
34.      | override val aPublic = tmp * 10 // can't access super.aPrivate because it
35.  is class private so use tmp
36.      | }
37. defined class c3
39. scala> new c2(10).aPublic
40. res5: Int = 20
42. scala> new c3(10).aPublic
43. res6: Int = 100
45. scala> class c4( aPrivate:Int ) {
46.      | println(aPrivate)
47.      | private val private2 = aPrivate % 10
48.      | println(private2)
49.      | }
50. defined class c4
52. scala> new c4(22)
53. 22
54. 2
55. res7: c4 = c4@64d90254