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. }