Scala 访问修饰符

Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。

如果没有指定访问修饰符，默认情况下，Scala 对象的访问级别都是 public。

Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。

私有(Private)成员

用 private 关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用内部类。

  1. class Outer{
  2.     class Inner{
  3.     private def f(){println("f")}
  4.     class InnerMost{
  5.         f() // 正确
  6.         }
  7.     }
  8.     (new Inner).f() //错误
  9. }

(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类 Inner 之内。

但在 InnerMost 里访问 f 就没有问题的，因为这个访问包含在 Inner 类之内。

Java中允许这两种访问，因为它允许外部类访问内部类的私有成员。

保护(Protected)成员

在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。

  1. package p{
  2. class Super{
  3.     protected def f() {println("f")}
  4.     }
  5.     class Sub extends Super{
  6.         f()
  7.     }
  8.     class Other{
  9.         (new Super).f() //错误
  10.     }
  11. }

上例中，Sub 类对 f 的访问没有问题，因为 f 在 Super 中被声明为 protected，而 Sub 是 Super 的子类。相反，Other 对 f 的访问不被允许，因为 other 没有继承自 Super。而后者在 java 里同样被认可，因为 Other 与 Sub 在同一包里。

公共(Public)成员

Scala中，如果没有指定任何的修饰符，则默认为 public。这样的成员在任何地方都可以被访问。

  1. class Outer {
  2.    class Inner {
  3.       def f() { println("f") }
  4.       class InnerMost {
  5.          f() // 正确
  6.       }
  7.    }
  8.    (new Inner).f() // 正确因为 f() 是 public
  9. }

作用域保护

Scala中，访问修饰符可以通过使用限定词强调。格式为:

  1. private[x] 
  3. 或 
  5. protected[x]

这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。

这种技巧在横跨了若干包的大型项目中非常有用，它允许你定义一些在你项目的若干子包中可见但对于项目外部的客户却始终不可见的东西。

  1. package bobsrockets{
  2.     package navigation{
  3.         private[bobsrockets] class Navigator{
  4.          protected[navigation] def useStarChart(){}
  5.          class LegOfJourney{
  6.              private[Navigator] val distance = 100
  7.              }
  8.             private[this] var speed = 200
  9.             }
  10.         }
  11.         package launch{
  12.         import navigation._
  13.         object Vehicle{
  14.         private[launch] val guide = new Navigator
  15.         }
  16.     }
  17. }

上述例子中，类Navigator被标记为private[bobsrockets]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。

比如说，从Vehicle对象里对Navigator的访问是被允许的，因为对象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代码都不能访问类Navigator。