摘要
本文将讨论在 Scala 和 Java 中 Access Modifiers 的区别，并用代码进行验证。
private
闲话少说，直接上代码：
首先，下面是 Scala 中的代码：
class Outer {
class Inner {
private def f() = println("method f invoked")
class InnerMost {
f()
}
}
// (new Inner).f()
}
object Outer {
def main(args: Array[String]) = {
val outer = new Outer
val inner = new outer.Inner
val innerMost = new inner.InnerMost
}
}
上述代码运行会正确的打印出 method f invoked，可见 InnerMost 可以访问 Inner 中的 private 方法 f，但是我们把代码中的注释部分打开，集成开发环境（笔者这里使用的是 Scala IDE）就会提示错误：method f in class Inner cannot be accessed in Outer.this.Inner
下面我们来看一下 Java 中是怎样的？
public class Outer {
class Inner {
private void f(){
System.out.println("method f invoked");
}
class InnerMost {
public void innerMostF(){
(new Inner()).f();
}
}
}
public void outerF(){
(new Inner()).f();
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer outer = new Outer();
outer.outerF();
Outer.Inner inner = outer.new Inner();
Outer.Inner.InnerMost innerMost = inner.new InnerMost();
innerMost.innerMostF();
}
}
执行 OuterDemo 的 main 方法，会成功的打印出两行 method f invoked，可见方法 innerMostF 和 outerF 都执行成功，可见在 Java 中外层的类可以访问内层类的 private 方法，而在 Scala 中是不可以的。
protected
这次我们使用 Scala 的交互终端进行测试：
scala> class Super {
| protected def f() = println("method f invoked")
| }
defined class Super
scala> class Sub extends Super {
| f()
| }
defined class Sub
可见在 Scala 中，子类中可以访问父类的 protected 方法，我们再来定义一个 Other 类：
scala> class Other {
| (new Super).f()
| }
<console>:13: error: method f in class Super cannot be accessed in Super
Access to protected method f not permitted because
enclosing class Other is not a subclass of
class Super where target is defined
(new Super).f()
^
执行报错，可见在 Scala 中其它类不能访问一个类中的 protected 方法。
那么在 Java 中可以吗？
public class Super {
public static void main(String[] args) {
Sub sub = new Sub();
sub.subF();
Other other = new Other();
other.otherF();
}
protected void f(){
System.out.println("method f invoked");
}
}
class Sub extends Super {
public void subF(){
super.f();
}
}
class Other {
public void otherF(){
Super superClass = new Super();
superClass.f();
}
}
上述代码执行成功，并打印了两行method f invoked，可见在 Java 中除了子类可以访问父类的 protected 方法，其他类也可以正常的进行访问。
public
在 Scala 中没有显示的 public 修饰符，任何没有标记成 private 和 protected 的成员都是 public 级别的，public 级别的成员可以在任何地方访问。
补充：Scope of protection
相对于 Java 而言，Scala 中有更为细粒度的访问权限控制，比如 private[X] 或者 protected[X] ，其中 X 可以是封装包、类，或者单例对象。
这种细粒度的访问权限控制在大型项目中非常有用，比如对项目中的几个子 package 可见，但是对客户端隐藏，在 Spark 的源码中我们随处可以见到这样的代码，例如 private[streaming] 、private[sql] 等
另外在 Scala 中有一种比 private 更为严格的权限控制，那就是 private[this] ，下面我们通过具体的例子来说明其具体的含义：
这里我们依然使用 Scala 的交互式终端进行测试
scala> class Person(private val gender: String){
| def getOtherGender(other: Person) = other.gender
| }
scala> val p1 = new Person("male")
p1: Person = Person@15ff3e9e
scala> val p2 = new Person("female")
p2: Person = Person@35cabb2a
scala> p1.getOtherGender(p2)
res6: String = female
上面的例子中我们定义了一个 Person 类，有一个私有的成员变量 gender，和一个获取另一个 Person 实例的gender 的方法，接下来我们实例化了两个 Person 对象 p1 和 p2，gender 分别为 male 和 female，最后我们通过 p1 的 getOtherGender 方法成功获得了 p2 的 gender，接下来我们使用 private[this] 来让 p1 不能访问 p2 的 gender
scala> class Person(private[this] val gender: String){
| def getOtherGender(other: Person) = other.gender
| }
<console>:13: error: value gender is not a member of Person
def getOtherGender(other: Person) = other.gender
注意，上面的代码中我们给 gender 添加了 private[this] 修饰，报错信息是 gender 不是 Person 的成员，也就是说，gender 只是 Person 的实例化对象私有的，一个实例化对象不能访问另一个实例化对象（当然是同一个类的）gender 成员变量。
总结
本文使用具体的例子简单的讨论了 Scala 和 Java 访问权限控制的区别，更多的目的是抛砖引玉，更多的功能和具体的用法需要在实际的项目开发中去验证。
本文参照：Programming in Scala, 3rd Edition 中的 13.5 ACCESS MODIFIERS
