scala 访问修饰符：private，protected，public

Scala 访问修饰符基本和Java的一样，分别有：private，protected，public，如果没有指定访问修饰符，默认情况下，Scala 对象的访问级别都是 public。

私有(Private)成员：

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

class Outer{
  class Inner{
    private def f(){
      println("f")
    }

    class InnerMost{
      f() // 正确
    }
  }

  // 错误。(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类 Inner 之内。
  // 但在 InnerMost 里访问 f 就没有问题的，因为这个访问包含在 Inner 类之内。

  // (new Inner).f()
}

保护(Protected)成员：

// 它只允许保护成员在定义了该成员的类，内部类，其子类中被访问，
// 同一个包里的其他类不可以进行访问。

package p{
  class Super{
    protected def f() {
      println("f")
    }

    class Inner{
      f()  // 正确
    }
  }

  class Sub extends Super{
    f()  // 正确。Sub 类对 f 的访问没有问题，因为 f 在 Super 中被声明为 protected，而 Sub 是 Super 的子类。
  }

  class Other{
    // 错误。Other 对 f 的访问不被允许，因为 other 没有继承自 Super。
    // (new Super).f()
  }
}

公共(Public)成员：

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

class Outer {
  class Inner {
    def f() {
      println("f")
    }

    class InnerMost {
      f() // 正确
    }
  }

  (new Inner).f() // 正确。因为 f() 是 public
}

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

/*
*  访问修饰符可以通过使用限定词强调。
*  格式为: private[x] 或 protected[x]
*  这里的x指代某个所属的包、类或单例对象。
*  如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对象可见外，对其它所有类都是private。
*/

package bobsrockets{
  package navigation{
    // 类 Navigator 被标记为 private[bobsrockets] 就是说这个类对包含在 bobsrockets 包里的所有的类和对象可见。
    private[bobsrockets] class Navigator{
      protected[navigation] def useStarChart(){}

      class LegOfJourney{
        private[Navigator] val distance = 100
      }

      private[this] var speed = 200
    }
  }

  package launch{
    import navigation._

    object Vehicle{
      // 从 Vehicle 对象里对 Navigator 的访问是被允许的，
      // 因为对象 Vehicle 包含在包 launch 中，而 launch 包在 bobsrockets 中，
      // 相反，所有在包 bobsrockets 之外的代码都不能访问类 Navigator。
      private[launch] val guide = new Navigator
    }
  }
}