scala基础-访问修饰符

scala的访问修饰符与java相同，拥有private，protected，public，在没有声明的情况下，默认是public。

1、private

class Animal{
  private def eat{
    println("Animal need food !")
  }
  class Mammal{
    eat // 内部类可以直接调用外部类的private方法
    private def Lactation{
      println("Mammal need lactation!")
    }
  }
  // Lactation 外部类不可直接调用内部的private方法 "not found: value Lactation"

}

Lactation访问不合法是因为 Lactation 在 Mammal中被声明为 private，而访问不在Mammal内部。
而Mammal可以直接其外部类Animal的private方法。

2、protected

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

object ProTest4 {
  def main(args: Array[String]): Unit = {
    val m1 = new Mammal()
    // m1.eat Animal2的protected方法不可被继承，但是可以子类被访问
    /*
     * method eat in class Animal2 cannot be accessed in 
     * com.yanch.cn.Mammal Access to protected method eat 
     * not permitted because enclosing object ProTest4 in 
     * package cn is not a subclass of class Animal2 
     * in package cn where target is defined
     */
    m1.run
  }
}

class Animal2{
  protected def eat{
    println("Animal need food !")
  }
  def run{
    println("Run")
  }
}

class Mammal extends Animal2{
  eat // 子类可以直接调用父类的protected方法
  private def Lactation{
    println("Mammal need lactation!")
    }
}

class Plant{
  (new Animal2).run
  //(new Animal2).eat 不可访问同包中的protected方法
}

输出：

Animal need food !
Run

3、public

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

4、作用域保护

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

private[x] 
或 
protected[x]

这里的x指代某个所属的包、类或单例对象。如果写成private[x],读作”这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。
这种技巧在横跨了若干包的大型项目中非常有用，它允许你定义一些在你项目的若干子包中可见但对于项目外部的客户却始终不可见的东西。

package bobsrocckets{
    package navigation{
        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{
        private[launch] val guide = new Navigator
        }
    }
}

上述例子中，类Navigator被标记为private[bobsrockets]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。
比如说，从Vehicle对象里对Navigator的访问是被允许的，因为对象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代码都不能访问类Navigator。